test(immobilienscout24): Added tests for IS24 classes

.github/workflows/test.yml

@@ -22,6 +22,9 @@ jobs:
       - name: 'lint'
         run: npm run lint
 
+      - name: 'test'
+        run: npm run test
+
       - name: 'build'
         run: npm run build
 

package.json

@@ -36,8 +36,8 @@
     "build:js": "babel src --out-dir lib --extensions \".ts,.js\" --source-maps inline",
     "build:watch": "npm run build:js -- --watch",
     "prepare": "npm run build",
-    "prepublishOnly": "npm run lint",
-    "preversion": "npm run lint",
+    "prepublishOnly": "npm run lint && npm run test",
+    "preversion": "npm run lint && npm run test",
     "version": "npm run format && git add -A src",
     "postversion": "git push && git push --tags"
   },

src/classes/portals/Estate.ts

@@ -149,9 +149,10 @@ export abstract class Estate {
     return value;
   }
 
-  protected getDate(path: any | any[], defaultValue?: any): number {
+  protected getDate(path: any | any[], defaultValue?: any): number | undefined {
     const value = this.getValue(path, defaultValue);
     if (!isNaN(value)) return Number(value);
+    if (!value) return undefined;
     return moment(value).valueOf();
   }
 

src/classes/portals/Immobilienscout24/Aggregator.test.ts

@@ -0,0 +1,40 @@
+import { Immobilienscout24 } from './Aggregator';
+import { credentials } from './__mocks__/request-promise-native';
+import { Aggregator } from '../Aggregator';
+import { Estate } from '../Estate';
+import en from '../../../translations/en';
+
+describe('Immobilienscout24 Aggregator', () => {
+  it('should initialize', () => {
+    const aggregator = new Immobilienscout24({
+      consumerKey: 'consumerKey',
+      consumerSecret: 'consumerSecret',
+      oauthToken: 'oauthToken',
+      oauthTokenSecret: 'oauthTokenSecret',
+    });
+    expect(aggregator).toBeInstanceOf(Aggregator);
+  });
+
+  it('should fetch aggregated estate', async () => {
+    const aggregator = new Immobilienscout24(credentials);
+
+    const result = await aggregator.fetchEstate('315859901');
+    expect(result).toBeInstanceOf(Estate);
+  });
+
+  it('should fetch aggregated estates', async () => {
+    const aggregator = new Immobilienscout24(credentials);
+
+    const result = await aggregator.fetchEstates();
+    result.forEach((res) => expect(res).toBeInstanceOf(Estate));
+    expect(result).toHaveLength(2);
+  });
+
+  it('should fetch get dictionary', async () => {
+    const aggregator = new Immobilienscout24(credentials);
+
+    const result = await aggregator.generateDictionary('en');
+    expect(result).toBeInstanceOf(Object);
+    expect(result).toBeDefined();
+  });
+});

src/classes/portals/Immobilienscout24/Estate.test.ts

@@ -0,0 +1,53 @@
+import { Immobilienscout24Estate } from './Estate';
+import { Estate } from '../Estate';
+import {
+  getResultEstate,
+  getResultCommon,
+  getResultProperties,
+  dictionary,
+} from './__mocks__/request-promise-native';
+
+describe('Immobilienscout24 Estate', () => {
+  it('should initialize', () => {
+    const estate = new Immobilienscout24Estate();
+    expect(estate).toBeInstanceOf(Estate);
+  });
+
+  it('should return common', async () => {
+    const estate = new Immobilienscout24Estate();
+
+    const result = await estate.init(getResultEstate());
+    expect(result).toBeInstanceOf(Estate);
+    const common = result.getCommon();
+    expect(common).toEqual(getResultCommon());
+  });
+
+  it('should return properties', async () => {
+    const estate = new Immobilienscout24Estate();
+
+    const result = await estate.init(getResultEstate());
+    expect(result).toBeInstanceOf(Estate);
+    const properties = result.getProperties();
+    expect(properties).toEqual(getResultProperties());
+  });
+
+  it('should return translated common', async () => {
+    const estate = new Immobilienscout24Estate();
+
+    const result = await estate.init(getResultEstate());
+    expect(result).toBeInstanceOf(Estate);
+
+    const common = result.getTranslatedCommon(dictionary);
+    expect(common).toEqual(getResultCommon(true));
+  });
+
+  it('should return translated properties', async () => {
+    const estate = new Immobilienscout24Estate();
+
+    const result = await estate.init(getResultEstate());
+    expect(result).toBeInstanceOf(Estate);
+
+    const common = result.getTranslatedProperties(dictionary);
+    expect(common).toEqual(getResultProperties(true));
+  });
+});

src/classes/portals/Immobilienscout24/Portal.test.ts

@@ -1,29 +1,26 @@
-import { Immobilienscout24Portal } from './Portal';
 import { Portal } from '../Portal';
-import estate from '../__mocks__/estate.json';
-import estates from '../__mocks__/estates.json';
-import estatesRecursive from '../__mocks__/estates-recursive.json';
-import { cloneDeep } from 'lodash';
+import { Immobilienscout24Portal } from './Portal';
+import {
+  getResultError,
+  getResultEstate,
+  getResultEstates,
+  credentials,
+} from './__mocks__/request-promise-native';
+
+const ENDPOINT = 'https://immobilienscout24.api/realestate';
 
 describe('Immobilienscout24 Portal', () => {
+  beforeAll(() => {
+    process.env.IS24_BASE_URL = ENDPOINT;
+  });
   describe('instance', () => {
     it('should initialize', () => {
-      const portal = new Immobilienscout24Portal({
-        consumerKey: 'consumerKey',
-        consumerSecret: 'consumerSecret',
-        oauthToken: 'oauthToken',
-        oauthTokenSecret: 'oauthTokenSecret',
-      });
+      const portal = new Immobilienscout24Portal(credentials);
       expect(portal).toBeInstanceOf(Portal);
     });
 
     it('should have base URL', () => {
-      const portal = new Immobilienscout24Portal({
-        consumerKey: 'consumerKey',
-        consumerSecret: 'consumerSecret',
-        oauthToken: 'oauthToken',
-        oauthTokenSecret: 'oauthTokenSecret',
-      });
+      const portal = new Immobilienscout24Portal(credentials);
       expect(portal.baseURL).toBeDefined();
     });
 
@@ -44,12 +41,7 @@ describe('Immobilienscout24 Portal', () => {
 
   describe('fetchEstate', () => {
     it('should return error', async () => {
-      const portal = new Immobilienscout24Portal({
-        consumerKey: 'consumerKey',
-        consumerSecret: 'consumerSecret',
-        oauthToken: 'oauthToken',
-        oauthTokenSecret: 'oauthTokenSecret',
-      });
+      const portal = new Immobilienscout24Portal(credentials);
 
       const result = await portal.fetchEstate('error');
       expect(result).toEqual({
@@ -59,101 +51,50 @@ describe('Immobilienscout24 Portal', () => {
         meta: {
           id: 'error',
         },
-        uri:
-          'https://rest.sandbox-immobilienscout24.de/restapi/api/offer/v1.0/user/me/realestate/error',
+        uri: `${ENDPOINT}/error`,
       });
     });
 
     it('should return 404 error', async () => {
-      const portal = new Immobilienscout24Portal({
-        consumerKey: 'consumerKey',
-        consumerSecret: 'consumerSecret',
-        oauthToken: 'oauthToken',
-        oauthTokenSecret: 'oauthTokenSecret',
-      });
+      const portal = new Immobilienscout24Portal(credentials);
 
       const result = await portal.fetchEstate('foo');
-      expect(result).toEqual({
-        type: 'error',
-        statusCode: 404,
-        message: 'NotFound',
-      });
+      expect(result).toEqual(getResultError());
     });
 
     it('should return estate', async () => {
-      const type = 'realestates.apartmentBuy';
-      const resultEstate = cloneDeep(estate[type]);
-      const portal = new Immobilienscout24Portal({
-        consumerKey: 'consumerKey',
-        consumerSecret: 'consumerSecret',
-        oauthToken: 'oauthToken',
-        oauthTokenSecret: 'oauthTokenSecret',
-      });
+      const portal = new Immobilienscout24Portal(credentials);
 
       const result = await portal.fetchEstate('315859901');
 
-      resultEstate.attachments = [{ attachment: 'exists' }];
-      resultEstate.type = type;
-      expect(result).toEqual(resultEstate);
+      expect(result).toEqual(getResultEstate());
     });
   });
 
   describe('fetchEstates', () => {
     it('should fetch multiple estates', async () => {
-      const resultEstates = cloneDeep(estates);
-      const portal = new Immobilienscout24Portal({
-        consumerKey: 'consumerKey',
-        consumerSecret: 'consumerSecret',
-        oauthToken: 'oauthToken',
-        oauthTokenSecret: 'oauthTokenSecret',
-      });
+      const portal = new Immobilienscout24Portal(credentials);
 
       const result = await portal.fetchEstates();
-      expect(result).toEqual(
-        resultEstates['realestates.realEstates'].realEstateList
-          .realEstateElement
-      );
+      expect(result).toEqual(getResultEstates());
     });
 
     it('should fetch recursively multiple estates', async () => {
-      const resultEstates = cloneDeep(estatesRecursive);
-      const portal = new Immobilienscout24Portal({
-        consumerKey: 'consumerKey',
-        consumerSecret: 'consumerSecret',
-        oauthToken: 'oauthToken',
-        oauthTokenSecret: 'oauthTokenSecret',
-      });
+      const portal = new Immobilienscout24Portal(credentials);
 
       const result = await portal.fetchEstates({
         recursively: true,
         pageSize: 2,
       });
-      expect(result).toEqual([
-        resultEstates['realestates.realEstates'].realEstateList
-          .realEstateElement,
-        resultEstates['realestates.realEstates'].realEstateList
-          .realEstateElement,
-      ]);
+      expect(result).toEqual([getResultEstates()[0], getResultEstates()[0]]);
     });
 
     it('should fetch multiple estates detailed', async () => {
-      const type = 'realestates.apartmentBuy';
-      const resultEstate = cloneDeep(estate[type]);
-      const portal = new Immobilienscout24Portal({
-        consumerKey: 'consumerKey',
-        consumerSecret: 'consumerSecret',
-        oauthToken: 'oauthToken',
-        oauthTokenSecret: 'oauthTokenSecret',
-      });
+      const portal = new Immobilienscout24Portal(credentials);
 
       const result = await portal.fetchEstates({ detailed: true });
-      resultEstate.attachments = [{ attachment: 'exists' }];
-      resultEstate.type = type;
 
-      expect(result).toEqual([
-        resultEstate,
-        { type: 'error', statusCode: 404, message: 'NotFound' },
-      ]);
+      expect(result).toEqual([getResultEstate(), getResultError()]);
     });
   });
 });