test: completely mock storage in tests using it

Closes #130

src/app/modules/data/data.provider.spec.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion,@typescript-eslint/ban-ts-comment,@typescript-eslint/no-explicit-any */
 /*
- * Copyright (C) 2018, 2019 StApps
+ * Copyright (C) 2018-2021 StApps
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation, version 3.
@@ -74,11 +74,11 @@ describe('DataProvider', () => {
     type: SCThingType.Message,
     uid: sampleThing.uid,
   };
-  const otherSampleThing: SCMessage = {
-    ...sampleThing,
-    uid: 'message-456',
-    name: 'bar',
-  };
+
+  const fakeStorage = new Map([
+    ['foo', 'Bar'],
+    ['bar', {foo: 'BarFoo'} as any],
+  ]);
 
   beforeEach(async () => {
     TestBed.configureTestingModule({
@@ -92,6 +92,7 @@ describe('DataProvider', () => {
 
   it('should generate data key', async () => {
     dataProvider.storagePrefix = 'foo.data';
+
     expect(dataProvider.getDataKey('123')).toBe('foo.data.123');
   });
 
@@ -104,6 +105,7 @@ describe('DataProvider', () => {
       };
     });
     const response = await dataProvider.search(sampleQuery);
+
     expect(response).toEqual(sampleResponse);
   });
 
@@ -116,6 +118,7 @@ describe('DataProvider', () => {
       },
     }));
     const response = await dataProvider.multiSearch({a: sampleQuery});
+
     expect(response).toEqual({a: sampleResponse});
   });
 
@@ -160,8 +163,8 @@ describe('DataProvider', () => {
         },
       }),
     );
-
     const response = await dataProvider.multiSearch(request);
+
     expect(response).toEqual(responseShould);
   });
 
@@ -173,22 +176,28 @@ describe('DataProvider', () => {
         providedThing.origin.created = sampleSavable.origin.created;
       },
     );
+
     expect(storageProvider.put).not.toHaveBeenCalled();
     expect(providedThing!).not.toBeDefined();
+
     await dataProvider.put(sampleThing);
+
     expect(providedThing!).toBeDefined();
     expect(providedThing!).toEqual(sampleSavable);
   });
 
   it('should correctly set and get single data item from the local database (storage)', async () => {
-    await dataProvider.put(sampleThing);
-    spyOn(storageProvider, 'get').and.callThrough();
+    spyOn(storageProvider, 'get').and.returnValue(
+      (async () => sampleSavable)(),
+    );
+
     expect(storageProvider.get).not.toHaveBeenCalled();
+
     const providedThing = await dataProvider.get(
       sampleThing.uid,
       DataScope.Local,
     );
-    providedThing.origin.created = sampleSavable.origin.created;
+
     expect(storageProvider.get).toHaveBeenCalledWith(
       dataProvider.getDataKey(sampleThing.uid),
     );
@@ -196,19 +205,20 @@ describe('DataProvider', () => {
   });
 
   it('should provide all data items from the local database (storage)', async () => {
-    await dataProvider.put(sampleThing);
-    await dataProvider.put(otherSampleThing);
-    const result = await dataProvider.getAll();
-    expect([...result.keys()].sort()).toEqual([
-      dataProvider.getDataKey(sampleThing.uid),
-      dataProvider.getDataKey(otherSampleThing.uid),
+    const fakeStorage = new Map([
+      ['foo', 'Bar'],
+      ['bar', {foo: 'BarFoo'} as any],
     ]);
-    expect(result.get(dataProvider.getDataKey(sampleThing.uid))!.data).toEqual(
-      sampleThing,
+    spyOn(storageProvider, 'search').and.callFake(async () => {
+      return fakeStorage;
+    });
+
+    const result = await dataProvider.getAll();
+
+    expect([...result.keys()].sort()).toEqual([...fakeStorage.keys()].sort());
+    expect([...result.values()].sort()).toEqual(
+      [...fakeStorage.values()].sort(),
     );
-    expect(
-      result.get(dataProvider.getDataKey(otherSampleThing.uid))!.data,
-    ).toEqual(otherSampleThing);
   });
 
   it('should provide single data from the backend', async () => {
@@ -219,11 +229,14 @@ describe('DataProvider', () => {
         },
       };
     });
+
     expect(Client.prototype.getThing).not.toHaveBeenCalled();
+
     const providedThing = await dataProvider.get(
       sampleThing.uid,
       DataScope.Remote,
     );
+
     expect(Client.prototype.getThing).toHaveBeenCalledWith(sampleThing.uid);
     expect(providedThing).toBe(sampleThing);
   });
@@ -244,39 +257,39 @@ describe('DataProvider', () => {
       };
     });
     const result = await dataProvider.get(sampleThing.uid);
+
     expect(result.get(DataScope.Local)).toEqual(sampleSavable);
     expect(result.get(DataScope.Remote)).toEqual(sampleThing);
   });
 
   it('should properly delete a data item from the local database (storage)', async () => {
-    spyOn(storageProvider, 'delete').and.callThrough();
-    await dataProvider.put(sampleThing);
-    expect(await storageProvider.length()).toBe(1);
+    spyOn(storageProvider, 'delete');
+
     await dataProvider.delete(sampleThing.uid);
+
     expect(storageProvider.delete).toHaveBeenCalledWith(
       dataProvider.getDataKey(sampleThing.uid),
     );
-    expect(await storageProvider.length()).toBe(0);
   });
 
   it('should properly delete all the data items from the local database (storage)', async () => {
-    spyOn(storageProvider, 'delete').and.callThrough();
-    await dataProvider.put(sampleThing);
-    await dataProvider.put(otherSampleThing);
-    await storageProvider.put('some-uid', {some: 'thing'});
-    expect(await storageProvider.length()).not.toBe(0);
+    spyOn(storageProvider, 'delete');
+    spyOn(storageProvider, 'search').and.callFake(async () => {
+      return fakeStorage;
+    });
     await dataProvider.deleteAll();
-    expect(storageProvider.delete).toHaveBeenCalledWith(
-      dataProvider.getDataKey(sampleThing.uid),
-      dataProvider.getDataKey(otherSampleThing.uid),
-    );
-    const result = await storageProvider.getAll();
-    expect([...result.keys()]).toEqual(['some-uid']);
+
+    expect(storageProvider.delete).toHaveBeenCalledWith('foo', 'bar');
   });
 
   it('should properly check if a data item has already been saved', async () => {
-    expect(await dataProvider.isSaved(sampleThing.uid)).toBeFalsy();
-    await dataProvider.put(sampleThing);
+    spyOn(storageProvider, 'has').and.callFake(async storageKey => {
+      return (async () => {
+        return dataProvider.getDataKey(sampleThing.uid) === storageKey;
+      })();
+    });
+
+    expect(await dataProvider.isSaved('some-uuid')).toBeFalsy();
     expect(await dataProvider.isSaved(sampleThing.uid)).toBeTruthy();
   });
 });