Refactoring browser storage service and adding unit tests.

src/_mocks/mocks.ts

@@ -3,6 +3,7 @@ import { Observable } from 'rxjs/Observable';
 import { IRule } from '../app/rule/common/rule-model';
 import { BehaviorSubject } from 'rxjs/BehaviorSubject';
 import { convertToParamMap, ParamMap } from '@angular/router';
+import { RuleBrowserStorageService } from '../app/rule/common';
 
 export class MockedNotificationService {
   notifySuccess(message: string) {
@@ -15,7 +16,7 @@ export class MockedNotificationService {
   }
 }
 
-export class MockedChromeStorageService {
+export class MockedRuleBrowserStorageService {
   setAll(rules: IRule[]): Observable<any> {
     return Observable.of({});
   }

src/app/app.component.spec.ts

@@ -8,12 +8,12 @@ import { AppMaterialModule } from './app-material.module';
 import { AppStore } from './store/app.store';
 import { NotificationService } from './common/notification.service';
 
-import { MockedChromeStorageService, MockedNotificationService, MockedRouter } from '../_mocks/mocks';
+import { MockedRuleBrowserStorageService, MockedNotificationService, MockedRouter } from '../_mocks/mocks';
 
 import { HeaderComponent } from './_layout/header.component';
 import { AppComponent } from './app.component';
 import { RuleActions } from './rule/common/rule.actions';
-import { ChromeStorageService, RuleService } from './rule/common/';
+import { RuleBrowserStorageService, RuleService } from './rule/common/';
 import { Icon, IIcon, IRule, Rule } from './rule/common/rule-model';
 
 class MockedRuleService {
@@ -43,7 +43,7 @@ describe('AppComponent', () => {
         { provide: Router, useClass: MockedRouter },
         { provide: RuleActions, useValue: new RuleActions() },
         { provide: NotificationService, useClass: MockedNotificationService },
-        { provide: ChromeStorageService, useClass: MockedChromeStorageService },
+        { provide: RuleBrowserStorageService, useClass: MockedRuleBrowserStorageService },
         { provide: RuleService, useClass: MockedRuleService }
       ],
       declarations: [

src/app/app.module.ts

@@ -12,7 +12,7 @@ import { HeaderComponent } from './_layout/';
 import { NotificationService, BrowserStorageProvider } from './common';
 import { AppStore } from './store/';
 
-import { RuleDashboardComponent, RuleDetailsComponent, RuleService, ChromeStorageService, RuleActions } from './rule';
+import { RuleDashboardComponent, RuleDetailsComponent, RuleService, RuleBrowserStorageService, RuleActions } from './rule';
 
 @NgModule({
   declarations: [
@@ -36,7 +36,7 @@ import { RuleDashboardComponent, RuleDetailsComponent, RuleService, ChromeStorag
     { provide: 'Chrome',  useValue: chrome },
     RuleService,
     NotificationService,
-    ChromeStorageService,
+    RuleBrowserStorageService,
     RuleActions,
     BrowserStorageProvider
   ],

src/app/rule/common/index.ts

@@ -2,5 +2,5 @@ export * from './rule-model';
 export * from './rule.reducer';
 export * from './rule.actions';
 export * from './rule.effects';
-export * from './chrome-storage.service';
+export * from './rule-browser-storage.service';
 export * from './rule.service';

src/app/rule/common/rule-browser-storage.service.spec.ts

@@ -0,0 +1,122 @@
+import { TestBed } from '@angular/core/testing';
+import { RuleBrowserStorageService } from './rule-browser-storage.service';
+import { BrowserStorageProvider } from '../../common';
+import { IStorage, StorageType } from '../../common';
+
+class MockedBrowserStorageProvider {
+  // used to mock chrome.
+  public useChromeStorage: boolean;
+
+  public mockedChrome = {
+    sync: {
+      set: function (items: any) {
+      },
+      get: function (key: string) {
+      }
+    }
+  };
+  public mockedLocalStorage = {
+    setItem: function () {
+    },
+    getItem: function () {
+    },
+    length: 0
+  };
+
+  getStorage(): IStorage {
+    if (this.useChromeStorage) {
+      return <IStorage> {
+        storage: this.mockedChrome,
+        type: StorageType.Chrome
+      };
+    }
+    return <IStorage> {
+      storage: this.mockedLocalStorage,
+      type: StorageType.LocalStorage
+    };
+  }
+
+}
+
+describe('RuleBrowserStorageService', () => {
+  let ruleBrowserStorageService: RuleBrowserStorageService;
+  let browserStorageProvider: MockedBrowserStorageProvider;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        RuleBrowserStorageService,
+        { provide: BrowserStorageProvider, useClass: MockedBrowserStorageProvider }
+      ]
+    });
+  });
+
+  beforeEach(() => {
+
+  });
+
+  it('should be created', () => {
+    ruleBrowserStorageService = TestBed.get(RuleBrowserStorageService);
+    browserStorageProvider = TestBed.get(BrowserStorageProvider);
+    expect(ruleBrowserStorageService).toBeTruthy();
+  });
+
+  it('chrome storage - should call get all', () => {
+    // sets mock to return chrome storage
+    browserStorageProvider = TestBed.get(BrowserStorageProvider);
+    browserStorageProvider.useChromeStorage = true;
+
+    ruleBrowserStorageService = TestBed.get(RuleBrowserStorageService);
+    spyOn(browserStorageProvider.mockedChrome.sync, 'get');
+
+    // Act
+    ruleBrowserStorageService.getAll();
+
+    expect(browserStorageProvider.mockedChrome.sync.get).toHaveBeenCalled();
+  });
+
+  it('chrome storage - should call set all', () => {
+    // sets mock to return chrome storage
+    browserStorageProvider = TestBed.get(BrowserStorageProvider);
+    browserStorageProvider.useChromeStorage = true;
+
+    ruleBrowserStorageService = TestBed.get(RuleBrowserStorageService);
+    spyOn(browserStorageProvider.mockedChrome.sync, 'set');
+
+    // Act
+    ruleBrowserStorageService.setAll([]);
+
+    expect(browserStorageProvider.mockedChrome.sync.set).toHaveBeenCalled();
+  });
+
+  it('local storage - should call get all', () => {
+    // sets mock to return local storage
+    browserStorageProvider = TestBed.get(BrowserStorageProvider);
+    browserStorageProvider.useChromeStorage = false;
+
+    ruleBrowserStorageService = TestBed.get(RuleBrowserStorageService);
+    spyOn(browserStorageProvider.mockedLocalStorage, 'getItem');
+
+    // Act
+    ruleBrowserStorageService.getAll();
+
+    expect(browserStorageProvider.mockedLocalStorage.getItem).toHaveBeenCalled();
+  });
+
+  it('local storage - should call set all', () => {
+    // sets mock to return local storage
+    browserStorageProvider = TestBed.get(BrowserStorageProvider);
+    browserStorageProvider.useChromeStorage = false;
+
+    ruleBrowserStorageService = TestBed.get(RuleBrowserStorageService);
+    spyOn(browserStorageProvider.mockedLocalStorage, 'setItem');
+
+    // Act
+    ruleBrowserStorageService.setAll([]);
+
+    expect(browserStorageProvider.mockedLocalStorage.setItem).toHaveBeenCalled();
+  });
+
+});
+
+

src/app/rule/common/chrome-storage.service.ts → src/app/rule/common/rule-browser-storage.service.ts

@@ -6,7 +6,7 @@ import { IRule, StorageRules } from './rule-model';
 import { IStorage, StorageType, BrowserStorageProvider } from '../../common';
 
 @Injectable()
-export class ChromeStorageService {
+export class RuleBrowserStorageService {
 
   private storage_key = 'envGuard';
   private browserStorage: IStorage;
@@ -21,7 +21,7 @@ export class ChromeStorageService {
    */
   setAll(rules: IRule[]): Observable<any> {
     const storage = new StorageRules(rules);
-    return Observable.from(new Promise((resolve, reject) => {
+    return Observable.from(new Promise((resolve, _) => {
       if (this.browserStorage.type === StorageType.Chrome) {
         this.browserStorage.storage.sync.set(storage, () => {
           resolve(true);
@@ -36,8 +36,8 @@ export class ChromeStorageService {
   /**
    * gets all rules from either local or chrome storage.
    */
-  getAllFromLocalStorage(): Observable<IRule[]> {
-    return Observable.from(new Promise((resolve, reject) => {
+  getAll(): Observable<IRule[]> {
+    return Observable.from(new Promise((resolve, _) => {
       if (this.browserStorage.type === StorageType.Chrome) {
         this.browserStorage.storage.sync.get(this.storage_key, (items: any) => {
           resolve(items[this.storage_key]);

src/app/rule/common/rule.service.spec.ts

@@ -1,19 +1,19 @@
 import { async, TestBed } from '@angular/core/testing';
-import { ChromeStorageService } from './index';
+import { RuleBrowserStorageService } from './index';
 import { RuleService } from './rule.service';
 import { HttpClientModule } from '@angular/common/http';
 import { Icon, IIcon, IRule, Rule } from './rule-model';
 import { Observable } from 'rxjs/Observable';
 
-class MockedChromeStorageService {
+class MockedRuleBrowserStorageService {
 
   public static mockedRules: IRule[] = [
     new Rule(null, 'Production', 'http://production.com', 'Exact', 'Production', null),
     new Rule(null, 'Staging', 'http://staging.com', 'Exact', 'Staging', null)
   ];
 
-  getAllFromLocalStorage$: Observable<IRule[]> = Observable.of(MockedChromeStorageService.mockedRules);
-  getAllFromLocalStorage(): Observable<IRule[]> {
+  getAllFromLocalStorage$: Observable<IRule[]> = Observable.of(MockedRuleBrowserStorageService.mockedRules);
+  getAll(): Observable<IRule[]> {
     return this.getAllFromLocalStorage$;
   }
 
@@ -24,21 +24,21 @@ class MockedChromeStorageService {
 
 describe('RuleService', () => {
   let ruleService: RuleService;
-  let chromeStorageService: ChromeStorageService;
+  let ruleBrowserStorageService: RuleBrowserStorageService;
 
   beforeEach(async(() => {
     TestBed.configureTestingModule({
       imports: [HttpClientModule],
       providers: [
-        { provide: ChromeStorageService, useClass: MockedChromeStorageService },
+        { provide: RuleBrowserStorageService, useClass: MockedRuleBrowserStorageService },
         RuleService
       ]
     });
   }));
 
   beforeEach(() => {
     ruleService = TestBed.get(RuleService);
-    chromeStorageService = TestBed.get(ChromeStorageService);
+    ruleBrowserStorageService = TestBed.get(RuleBrowserStorageService);
   });
 
   it('should create service', () => {
@@ -52,20 +52,20 @@ describe('RuleService', () => {
   });
 
   it('should get all rules from chrome storage', () => {
-    spyOn(chromeStorageService, 'getAllFromLocalStorage').and.callThrough();
+    spyOn(ruleBrowserStorageService, 'getAll').and.callThrough();
 
     ruleService.getAllRules().subscribe((rules: IRule[]) => {
-      expect(rules).toEqual(MockedChromeStorageService.mockedRules);
-      expect(chromeStorageService.getAllFromLocalStorage).toHaveBeenCalled();
+      expect(rules).toEqual(MockedRuleBrowserStorageService.mockedRules);
+      expect(ruleBrowserStorageService.getAll).toHaveBeenCalled();
     });
   });
 
   it('should call save rules on chrome storage service', () => {
-    spyOn(chromeStorageService, 'setAll').and.callThrough();
-    const expectedRules = MockedChromeStorageService.mockedRules;
+    spyOn(ruleBrowserStorageService, 'setAll').and.callThrough();
+    const expectedRules = MockedRuleBrowserStorageService.mockedRules;
 
     ruleService.saveRules(expectedRules).subscribe(() => {
-      expect(chromeStorageService.setAll).toHaveBeenCalledWith(expectedRules);
+      expect(ruleBrowserStorageService.setAll).toHaveBeenCalledWith(expectedRules);
     });
   });
 

src/app/rule/common/rule.service.ts

@@ -3,14 +3,14 @@ import { HttpClient } from '@angular/common/http';
 import 'rxjs/add/operator/map';
 import { Observable } from 'rxjs/Observable';
 
-import { ChromeStorageService } from './chrome-storage.service';
+import { RuleBrowserStorageService } from './rule-browser-storage.service';
 import { IIcon, IRule } from './rule-model';
 
 @Injectable()
 export class RuleService {
 
   constructor(private http: HttpClient,
-              private chromeStorage: ChromeStorageService) {  }
+              private chromeStorage: RuleBrowserStorageService) {  }
 
   /**
    * Returns the list of default icons
@@ -38,6 +38,6 @@ export class RuleService {
    * @returns {Observable<IRule[]>}
    */
   getAllRules(): Observable<IRule[]> {
-    return this.chromeStorage.getAllFromLocalStorage();
+    return this.chromeStorage.getAll();
   }
 }

src/app/rule/dashboard/rule-dashboard.component.spec.ts

@@ -6,13 +6,13 @@ import { By } from '@angular/platform-browser';
 import { Store } from '@ngrx/store';
 
 import { AppStore } from '../../store/app.store';
-import { MockedChromeStorageService, MockedNotificationService, MockedRouter } from '../../../_mocks/mocks';
+import { MockedRuleBrowserStorageService, MockedNotificationService, MockedRouter } from '../../../_mocks/mocks';
 
 import { RuleDashboardComponent } from './rule-dashboard.component';
 import { NotificationService } from '../../common/notification.service';
 
 import { Icon, IIcon, IRule, Rule } from '../common/rule-model';
-import { ChromeStorageService, RuleActions, RuleService } from '../common/';
+import { RuleBrowserStorageService, RuleActions, RuleService } from '../common/';
 import { IAppStore } from '../../store/common/store.model';
 
 class MockedRuleService {
@@ -57,7 +57,7 @@ describe('RuleDashboardComponent', () => {
         { provide: Router, useClass: MockedRouter },
         { provide: RuleActions, useValue: new RuleActions() },
         { provide: NotificationService, useClass: MockedNotificationService },
-        { provide: ChromeStorageService, useClass: MockedChromeStorageService },
+        { provide: RuleBrowserStorageService, useClass: MockedRuleBrowserStorageService },
         { provide: RuleService, useClass: MockedRuleService }
       ],
       declarations: [RuleDashboardComponent]

src/app/rule/details/rule-details.component.spec.ts

@@ -9,12 +9,12 @@ import { AppMaterialModule } from '../../app-material.module';
 import { NotificationService } from '../../common/notification.service';
 import {
   MockedActivatedRoute,
-  MockedChromeStorageService,
+  MockedRuleBrowserStorageService,
   MockedNotificationService,
   MockedRouter
 } from '../../../_mocks/mocks';
 
-import { ChromeStorageService, IRuleBanner, RuleActions, RuleBanner, RuleService } from '../common/';
+import { RuleBrowserStorageService, IRuleBanner, RuleActions, RuleBanner, RuleService } from '../common/';
 import { RuleDetailsComponent } from './rule-details.component';
 import { Icon, IIcon, IRule, Rule } from '../common/rule-model';
 import { Store } from '@ngrx/store';
@@ -69,7 +69,7 @@ describe('RuleDetailsComponent', () => {
         { provide: ActivatedRoute, useValue: activateRoute },
         { provide: RuleActions, useValue: new RuleActions() },
         { provide: NotificationService, useClass: MockedNotificationService },
-        { provide: ChromeStorageService, useClass: MockedChromeStorageService },
+        { provide: RuleBrowserStorageService, useClass: MockedRuleBrowserStorageService },
         { provide: RuleService, useClass: MockedRuleService }
       ],
       declarations: [RuleDetailsComponent]