Theaninova/openstapps
1
0
Fork 0
mirror of https://gitlab.com/openstapps/openstapps.git synced 2026-01-20 16:42:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

test: completely mock storage in tests using it

Browse Source 
Closes #130
This commit is contained in:
Jovan Krunić
2021-09-08 18:00:14 +02:00
parent 6f2990b804
commit 293ed6ba5f
2 changed files with 131 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
src/app/modules/storage/storage.provider.spec.ts
View File

@@ -31,50 +31,65 @@ describe('StorageProvider', () => {
beforeEach(async () => {
TestBed.configureTestingModule({
imports: [StorageModule],
providers: [
StorageProvider,
// { provide: Storage, useClass: StorageMock }
],
providers: [StorageProvider],
});
storageProvider = TestBed.get(StorageProvider);
storage = TestBed.get(Storage);
await storage.clear();
spyOn(storage, 'forEach').and.callFake(function_ => {
let i = 0;
for (const key of sampleEntries.keys()) {
function_(sampleEntries.get(key), key, i);
i++;
}
return (async () => {
/* just return a promise */
})();
});
});
it('should call ready method of storage on init', () => {
spyOn(storage, 'ready');
storageProvider.init();
expect(storage.ready).toHaveBeenCalled();
});
it('should call set method of storage to put a value', () => {
spyOn(storage, 'set');
storageProvider.put('some-uid', {some: 'thing'});
expect(storage.set).toHaveBeenCalledWith('some-uid', {some: 'thing'});
});
it('should call get method of storage to get a value', () => {
spyOn(storage, 'get');
storageProvider.get<any>('some-uid');
storageProvider.get('some-uid');
expect(storage.get).toHaveBeenCalledWith('some-uid');
});
it('should properly put and get a value', async () => {
const fakeStorageSystem = new Map<string, any>();
spyOn(storage, 'set').and.callFake((id, value) => {
return (async () => fakeStorageSystem.set(id, value))();
});
spyOn(storage, 'get').and.callFake(id => {
return (async () => fakeStorageSystem.get(id))();
});
await storageProvider.init();
await storageProvider.put('some-uid', {some: 'thing'});
// eslint-disable-next-line @typescript-eslint/ban-types
const result: Map<string, object> = await storageProvider.get<
// eslint-disable-next-line @typescript-eslint/ban-types
Map<string, object>
>('some-uid');
await expect(result).toEqual({some: 'thing'});
const result = await storageProvider.get('some-uid');
expect(result).toEqual({some: 'thing'});
});
it('should throw an error when value is null', async () => {
// eslint-disable-next-line unicorn/error-message
let error: Error = new Error();
// eslint-disable-next-line unicorn/no-null
spyOn(storage, 'get').and.returnValue(Promise.resolve(null));
spyOn(storage, 'get').and.returnValue((async () => null)());
try {
await storageProvider.get('something-else');
} catch (error_) {
@@ -86,101 +101,103 @@ describe('StorageProvider', () => {
it('should put multiple values into the storage', async () => {
spyOn(storageProvider, 'put');
await storageProvider.putMultiple(sampleEntries);
expect((storageProvider.put as jasmine.Spy).calls.count()).toEqual(3);
expect(storageProvider.put).toHaveBeenCalledWith('foo', 'Bar');
expect(storageProvider.put).toHaveBeenCalledWith('bar', {foo: 'BarFoo'});
expect(storageProvider.put).toHaveBeenCalledTimes(sampleEntries.size);
for (const key of sampleEntries.keys()) {
expect(storageProvider.put).toHaveBeenCalledWith(
key,
sampleEntries.get(key),
);
}
});
it('should get multiple values from the storage', async () => {
spyOn(storageProvider, 'get').and.callThrough();
await storageProvider.putMultiple(sampleEntries);
spyOn(storageProvider, 'get').and.callFake(id => {
return (async () => sampleEntries.get(id))();
});
const entries = await storageProvider.getMultiple(['foo', 'bar']);
expect((storageProvider.get as jasmine.Spy).calls.count()).toEqual(2);
expect(storageProvider.get).toHaveBeenCalledTimes(2);
expect(storageProvider.get).toHaveBeenCalledWith('foo');
expect(storageProvider.get).toHaveBeenCalledWith('bar');
expect([...entries.values()]).toEqual(['Bar', {foo: 'BarFoo'}]);
expect([...entries.keys()]).toEqual(['foo', 'bar']);
});
it('should get all values from the storage', async () => {
spyOn(storageProvider, 'get').and.callThrough();
await storageProvider.putMultiple(sampleEntries);
const entries = await storageProvider.getAll();
expect(
[...entries.values()].map(item => (item.foo ? item.foo : item)).sort(),
).toEqual(
[...sampleEntries.values()]
.map(item => (item.foo ? item.foo : item))
.sort(),
);
expect([...entries.keys()].sort()).toEqual(['bar', 'foo', 'foo.bar']);
const allValuesMap = await storageProvider.getAll();
for (const key of sampleEntries.keys()) {
expect(allValuesMap.get(key)).toEqual(sampleEntries.get(key));
}
});
it('should delete one or more entries from the storage', async () => {
spyOn(storage, 'remove').and.callThrough();
await storageProvider.putMultiple(sampleEntries);
let entries = await storageProvider.getAll();
expect([...entries.values()].length).toBe(3);
await storageProvider.delete('bar');
const storageRemoveSpy = spyOn(storage, 'remove');
expect(storage.remove).toHaveBeenCalled();
entries = await storageProvider.getAll();
expect([...entries.values()]).toEqual(['Bar', 123]);
await storageProvider.delete('bar');
expect(storage.remove).toHaveBeenCalledTimes(1);
storageRemoveSpy.calls.reset();
await storageProvider.delete('foo', 'foo.bar');
expect(await storageProvider.length()).toBe(0);
expect(storage.remove).toHaveBeenCalledTimes(2);
});
it('should delete all entries in the storage', async () => {
spyOn(storage, 'clear').and.callThrough();
await storageProvider.putMultiple(sampleEntries);
let entries = await storageProvider.getAll();
expect([...entries.values()].length).not.toBe(0);
spyOn(storage, 'clear');
await storageProvider.deleteAll();
entries = await storageProvider.getAll();
expect(storage.clear).toHaveBeenCalled();
expect([...entries.values()].length).toBe(0);
});
it('should provide number of entries', async () => {
spyOn(storage, 'length').and.callThrough();
expect(await storageProvider.length()).toBe(0);
expect(storage.length).toHaveBeenCalled();
await storageProvider.putMultiple(sampleEntries);
expect(await storageProvider.length()).toBe(3);
});
it('should provide information if storage is empty', async () => {
spyOn(storage, 'length').and.callThrough();
let n: number;
spyOn(storage, 'length').and.callFake(async () => n);
expect(await storageProvider.isEmpty()).toBeTruthy();
expect(storage.length).toHaveBeenCalled();
n = 0;
await storageProvider.putMultiple(sampleEntries);
const testEmpty = await storageProvider.isEmpty();
expect(testEmpty).toBeTruthy();
n = 1;
expect(await storageProvider.isEmpty()).toBeFalsy();
expect(storage.length).toHaveBeenCalledTimes(2);
});
it('should provide number of entries', async () => {
const n = 5;
spyOn(storage, 'length').and.callFake(async () => n);
expect(await storageProvider.length()).toBe(n);
});
it('should provide information if storage contains a specific entry (key)', async () => {
spyOn(storage, 'keys').and.returnValue(
Promise.resolve([...sampleEntries.keys()]),
(async () => [...sampleEntries.keys()])(),
);
expect(await storageProvider.has('foo')).toBeTruthy();
expect(await storageProvider.has('something-else')).toBeFalsy();
});
it('should allow search by regex', async () => {
await storageProvider.putMultiple(sampleEntries);
const found: Map<string, any> = await storageProvider.search<any>(/bar/);
expect([...found.keys()].sort()).toEqual(['bar', 'foo.bar']);
expect([...found.values()]).toEqual([{foo: 'BarFoo'}, 123]);
});
it('should allow search by string', async () => {
await storageProvider.putMultiple(sampleEntries);
spyOn(storage, 'get').and.callFake(id => {
return (async () => sampleEntries.get(id))();
});
const found: Map<string, any> = await storageProvider.search<any>('foo.ba');
expect([...found.keys()]).toEqual(['foo.bar']);
expect([...found.values()]).toEqual([123]);
});