Made tests. missing two functions

Author: jcguarinpenaranda

src/CachedResults.ts

@@ -4,33 +4,40 @@ export class CachedResults {
   createdAt: Date;
   results: any[];
 
+  static toParseObjs(className: string, results: any[]): Parse.Object[] {
+    return results.map((obj) => {
+      const jsonReadyToBeConverted = {
+        className,
+        ...obj,
+      };
+
+      // return Parse objects
+      return Parse.Object.fromJSON(jsonReadyToBeConverted, false);
+    });
+  }
+
   constructor(objs: Parse.Object[], createdAt?: Date) {
     this.createdAt = createdAt || new Date();
     this.results = objs.map(o => o.toJSON());
   }
 
+  toParseObjs(className: string) {
+    return CachedResults.toParseObjs(className, this.results);
+  }
+
   toJSON(): any {
     return {
       createdAt: this.createdAt,
-      resuts: this.results,
+      results: this.results,
     };
   }
 
-  toParseObjs(className: string): Parse.Object[] {
-    return this.results.map((obj) => {
-      const jsonReadyToBeConverted = {
-        className,
-        ...obj,
-      };
-
-      // return Parse objects
-      return Parse.Object.fromJSON(jsonReadyToBeConverted, false);
-    });
-  }
-
   static fromJSON(
     json: { createdAt: Date, results: any[] },
   ): CachedResults {
-    return new CachedResults(json.results, json.createdAt);
+    const { createdAt, results } = json;
+    const c = new CachedResults([], createdAt);
+    c.results = results;
+    return c;
   }
 }

src/ParseOffline.ts

@@ -32,7 +32,7 @@ export class ParseOffline {
     const results = await query.find(options);
 
     // Save the items in the localStorage as JSON
-    localStorage.setItem(
+    window.localStorage.setItem(
       cacheKey, 
       JSON.stringify(new CachedResults(results).toJSON()),
     );
@@ -51,13 +51,13 @@ export class ParseOffline {
   }): CachedResults {
     const { className, localStorageKey } = params;
 
-    const previousItems = localStorage.getItem(
+    const previousItems = window.localStorage.getItem(
       localStorageKey || // from an arbitrary key
       ParseOffline.getLocalStorageKeyForClassName(className), // for an autogenerated key
     );
 
     // return if there were no previous items
-    if (!previousItems) return;
+    if (!previousItems) return new CachedResults([]);
 
     // parse the previous results
     const parsedJSON: any = JSON.parse(previousItems);
@@ -104,7 +104,7 @@ export class ParseOffline {
     const { query, localStorageKey, options, maxAge } = params;
 
     // Get the previous items
-    const previousItems = localStorage.getItem(
+    const previousItems = window.localStorage.getItem(
       localStorageKey ||
       ParseOffline.getLocalStorageKeyForClassName(query.className),
     );

test/CachedResults.test.ts

@@ -0,0 +1,53 @@
+import * as Parse from 'parse/node';
+import { CachedResults } from '../src/CachedResults';
+
+const obj = new Parse.Object('Test');
+obj.set('testKey', 1);
+obj.set('test', true);
+
+const obj2 = obj.clone();
+obj2.set('testKey', 2);
+
+describe('#constructor', () => {
+  test('should initialize with the right results', () => {
+    const c = new CachedResults([obj, obj2]);
+    expect(c.results).toEqual([obj.toJSON(), obj2.toJSON()]);
+  });
+
+  test('should be able to initialize with the right date', () => {
+    const d = new Date();
+    const c = new CachedResults([obj, obj2], d);
+    expect(c.results).toEqual([obj.toJSON(), obj2.toJSON()]);
+    expect(c.createdAt).toEqual(d);
+  });
+});
+
+describe('#toJSON', () => {
+  test('should return the right data', () => {
+    const d = new Date();
+    const c = new CachedResults([obj, obj2], d);
+    expect(c.toJSON()).toEqual({
+      createdAt: d,
+      results: [obj.toJSON(), obj2.toJSON()],
+    });
+  });
+});
+
+describe('#toParseObjs', () => {
+  test('should convert back to Parse.Objects', () => {
+    const d = new Date();
+    const c = new CachedResults([obj, obj2], d);
+    expect(CachedResults.toParseObjs('Test', [obj.toJSON(), obj2.toJSON()])).toEqual([obj, obj2]);
+  });
+});
+
+describe('#fromJSON', () => {
+  test('should convert the results ok', () => {
+    const results = [obj.toJSON(), obj2.toJSON()];
+    const createdAt = new Date();
+    const result = CachedResults.fromJSON({ createdAt, results });
+
+    expect(result instanceof CachedResults).toBe(true);
+    expect(result.toParseObjs('Test').map(t => t.toJSON())).toEqual(results);
+  });
+});

test/ParseOffline.test.ts

@@ -0,0 +1,86 @@
+import * as Parse from 'parse/node';
+import { ParseOffline } from '../src/ParseOffline';
+import { CachedResults } from '../src/CachedResults';
+
+const obj = new Parse.Object('Test');
+obj.set('testKey', 1);
+obj.set('test', true);
+
+const obj2 = obj.clone();
+obj2.set('testKey', 2);
+
+const store: any = {};
+
+beforeAll(() => {
+  Object.assign(window, { 
+    localStorage: { 
+      setItem: (key: string, value: string) => {
+        store[key] = value;
+      }, 
+      getItem: key => store[key], 
+    }, 
+  });
+});
+
+describe('#saveResultsToLocalStorage', () => {
+  test('should save the results in a way they can be retrieved back as Parse Objects', async () => {
+    const query = new Parse.Query('Test');
+    const spy = jest.spyOn(query, 'find');
+    spy.mockImplementationOnce(async () => [obj, obj2]);
+
+    const spyStorage = jest.spyOn(localStorage, 'setItem');
+
+    const results = await ParseOffline.saveResultsToLocalStorage({ 
+      query,
+      options: { sessionToken: '123' },
+    });
+
+    expect(spyStorage).toHaveBeenCalledTimes(1);
+    expect(results).toEqual([obj, obj2]);
+
+    const str = localStorage.getItem('_cache_Test');
+    const json = JSON.parse(str);
+
+
+    const cachedResults = CachedResults
+      .fromJSON({ ...json, className: 'Test' });
+
+    expect(cachedResults.toParseObjs('Test').map(o => o.toJSON()))
+      .toEqual([obj.toJSON(), obj2.toJSON()]);
+  });
+});
+
+
+describe('#getLocalStorageKeyForClassName', () => {
+  test('should return the right key', () => {
+    expect(ParseOffline.getLocalStorageKeyForClassName('Test'))
+      .toEqual('_cache_Test');
+  });
+});
+
+describe('#getClassNameFromLocalStorageKey', () => {
+  test('should return the right name', () => {
+    expect(ParseOffline.getClassNameFromLocalStorageKey('_cache_Test'))
+      .toEqual('Test');
+  });
+});
+
+describe('#getResultsFromTheLocalStorage', () => {
+  test('should return the results from the localStorage', async () => {
+    const results = await ParseOffline.getResultsFromTheLocalStorage({ 
+      className: 'Test', 
+    });
+
+    expect(results.toParseObjs('Test').map(o => o.toJSON()))
+      .toEqual([obj.toJSON(), obj2.toJSON()]);
+  });
+
+  test('should return an empty CachedResults if there were no results in the localStorage', 
+       async () => {
+         const results = await ParseOffline.getResultsFromTheLocalStorage({ 
+           className: 'IDontExist', 
+         });
+
+         expect(results.results).toEqual([]);
+       });
+});