fix release provider and tests

src/app/app.module.ts

@@ -66,7 +66,7 @@ import { ScanProvider } from '../providers/scan/scan';
 import { TouchIdProvider } from '../providers/touchid/touchid';
 import { TxFormatProvider } from '../providers/tx-format/tx-format';
 import { WalletProvider } from '../providers/wallet/wallet';
-import { LatestReleaseProvider } from '../providers/latestRelease/latestRelease';
+import { ReleaseProvider } from '../providers/release/release';
 
 export function createTranslateLoader(http: Http) {
   return new TranslatePoHttpLoader(http, 'assets/i18n', '.po');
@@ -116,7 +116,7 @@ let providers: any = [
   TouchIdProvider,
   TxFormatProvider,
   WalletProvider,
-  LatestReleaseProvider,
+  ReleaseProvider,
   {
     provide: ErrorHandler,
     useClass: IonicErrorHandler

src/pages/home/home.ts

@@ -1,7 +1,7 @@
 import { Component } from '@angular/core';
 import { NavController } from 'ionic-angular';
 import { ProfileProvider } from '../../providers/profile/profile';
-import { LatestReleaseProvider } from '../../providers/latestRelease/latestRelease';
+import { ReleaseProvider } from '../../providers/release/release';
 
 @Component({
   selector: 'page-home',
@@ -13,19 +13,22 @@ export class HomePage {
   constructor(
     public navCtrl: NavController,
     private profile: ProfileProvider,
-    private latestRelease: LatestReleaseProvider,
+    private release: ReleaseProvider,
   ) {
+    this.release.getLatestAppVersion()
+    .catch((err) => {
+      console.log('Error:', err)})
+    .then((version) => {
+      console.log('Current app version:',version);
+      var result = this.release.checkForUpdates(version);
+      console.log('Update available:', result.updateAvailable);
+    });
   }
 
   ionViewDidLoad() {
     console.log('ionViewDidLoad HomePage');
 
     this.wallets = this.profile.bind();
-    this.latestRelease.checkLatestRelease().then((response) => {
-      console.log('New release available: ', response);
-    }).catch((error) => {
-      console.log('Latest Release error: ', error);
-    });
     console.log('[home.ts:20]', this.wallets); //TODO
   }
 }

src/providers/latestRelease/latestRelease.spec.ts

@@ -1,45 +0,0 @@
-import { LatestReleaseProviderStub } from '../../../test-config/mocks/latestRelease';
-
-describe('Latest Release Provider', () => {
-  var currentVersion: string;
-  var latestVersion: string;
-
-  beforeEach(() => {
-    // Using the mock => 3.3.3
-    latestVersion = LatestReleaseProviderStub.checkLatestRelease(null, null);
-  });
-
-  it('should check successfully the latest release of the app', () => {
-    expect(latestVersion).toBeDefined();
-  });
-
-  it('should check unsuccessfully the current release format of the app', () => {
-    const result = LatestReleaseProviderStub.checkLatestRelease('V.3.3.3', '3.3.3');
-    expect(result).toMatch('Cannot');
-    expect(result).toMatch('version tag');
-  });
-
-  it('should check unsuccessfully the latest release format of the app', () => {
-    const result = LatestReleaseProviderStub.checkLatestRelease('3.3.3', 'V.3.3.3');
-    expect(result).toMatch('Cannot');
-    expect(result).toMatch('release tag');
-  });
-
-  it('should compare the current and latest version of the app with the same value', () => {
-    currentVersion = '3.3.3';
-    const result = LatestReleaseProviderStub.checkLatestRelease(currentVersion, latestVersion);
-    expect(result).toBeFalsy();
-  });
-
-  it('there should be a new version available', () => {
-    currentVersion = '3.2.3';
-    const result = LatestReleaseProviderStub.checkLatestRelease(currentVersion, latestVersion);
-    expect(result).toBeTruthy();
-  });
-
-  it('there should not be a new version available', () => {
-    currentVersion = '3.3.2';
-    const result = LatestReleaseProviderStub.checkLatestRelease(currentVersion, latestVersion);
-    expect(result).toBeFalsy();
-  });
-});

src/providers/release/release.spec.ts

@@ -0,0 +1,86 @@
+import { TestBed, inject, async } from '@angular/core/testing';
+import { Http } from '@angular/http';
+import { AppProvider } from '../../providers/app/app';
+import { ReleaseProvider } from './release';
+
+describe('Release Provider', () => {
+  let service: ReleaseProvider;
+  let currentAppVersion, latestAppVersion;
+
+  class AppProviderMock {
+    private info: any;
+    constructor() {
+      this.info = { version: '1.1.1' };
+    };
+  };
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        ReleaseProvider, 
+        { provide: Http },
+        { provide: AppProvider, useClass: AppProviderMock },  
+      ]
+    });
+  });
+
+  beforeEach(inject([ReleaseProvider], (releaseService: ReleaseProvider) => {
+    // Mocks
+    service = releaseService;
+    currentAppVersion = '1.1.1';
+    latestAppVersion = '2.2.2';
+  }));
+
+  it('should get successfully the current app version', () => {
+    // Should return the AppProviderMock object
+    const appVersion = service.getCurrentAppVersion();
+    
+    expect(appVersion).toBeDefined();
+    expect(appVersion).toEqual(currentAppVersion);
+  });
+
+  it('should get successfully the latest app version', async(() => {
+    spyOn(service, 'getLatestAppVersion').and.returnValue(Promise.resolve(latestAppVersion));
+
+    service.getLatestAppVersion()
+      .catch((err) => expect(err).toBeNull)
+      .then((version) => {
+        expect(version).toBeDefined();
+        expect(version).toEqual(latestAppVersion);
+      });
+  }));
+    
+  it('should check unsuccessfully the current app version format', () => {
+    const result = service.checkForUpdates(latestAppVersion, 'V..3.3.3');
+    
+    expect(result.error).toBeDefined();
+    expect(result.error).toMatch('Cannot');
+    expect(result.error).toMatch('version tag');
+  });
+  
+  it('should check unsuccessfully the latest app version format', () => {
+    const result = service.checkForUpdates('V..3.3.3', currentAppVersion);
+    
+    expect(result.updateAvailable).toBeNull;
+    expect(result.availabeVersion).toBeNull;
+    expect(result.error).toBeDefined();
+    expect(result.error).toMatch('Cannot');
+    expect(result.error).toMatch('release tag');
+  });
+
+  it('should compare the current and latest app version with the same value', () => {
+    const result = service.checkForUpdates('1.1.1', '1.1.1');
+
+    expect(result.error).toBeNull;
+    expect(result.updateAvailable).toBeNull;
+    expect(result.availabeVersion).toBeNull;
+  });
+  
+  it('should be a new version available', () => {
+    const result = service.checkForUpdates(latestAppVersion, currentAppVersion);
+    
+    expect(result.error).toBeNull;
+    expect(result.updateAvailable).toBeTruthy;
+    expect(result.availabeVersion).toEqual(latestAppVersion);
+  });
+});

src/providers/release/release.ts

@@ -5,44 +5,50 @@ import 'rxjs/add/operator/toPromise';
 import { AppProvider } from '../../providers/app/app';
 
 @Injectable()
-export class LatestReleaseProvider {
+export class ReleaseProvider {
   private LATEST_RELEASE_URL: string;
   private appVersion: string;
 
   constructor(public http: Http, private app: AppProvider) {
-    console.log('Hello LatestRelease Provider');
     this.LATEST_RELEASE_URL = 'https://api.github.com/repos/bitpay/copay/releases/latest';
+    this.appVersion = this.app.info.version;
   }
   
   getCurrentAppVersion() {
-    return this.appVersion = this.app.info.version;
+    return this.appVersion;
   }
 
   getLatestAppVersion(): Promise<any> {
     return this.http.get(this.LATEST_RELEASE_URL)
-      .map((response) => response.json())
+      .map((response) => response.json().tag_name)
       .toPromise()
       .catch((error) => (error));
   }
 
-  checkForUpdates(currentVersion: string, latestVersion: string) {
+  checkForUpdates(latestVersion: string, currentVersion?: string) {
+    if (!currentVersion) currentVersion = this.appVersion;
+
     var result = {
-      updateAvailable: false,
+      updateAvailable: null,
+      availabeVersion: null,
       error: null
     };
 
     if (!verifyTagFormat(currentVersion))
-      return (result.error = 'Cannot verify the format of version tag: ' + currentVersion);
-    if (!verifyTagFormat(latestVersion))
-      return (result.error = 'Cannot verify the format of latest release tag: ' + latestVersion);
+      setErrorAndReturn('Cannot verify the format of version tag: ' + currentVersion);
+    if(!verifyTagFormat(latestVersion))
+      setErrorAndReturn('Cannot verify the format of latest release tag: ' + latestVersion);
 
     var current = formatTagNumber(currentVersion);
     var latest = formatTagNumber(latestVersion);
 
     if (latest.major < current.major || (latest.major == current.major && latest.minor <= current.minor))
       return (result);
-    else
-      return (result.updateAvailable = true);
+    else {
+      result.updateAvailable = true;
+      result.availabeVersion = latestVersion;
+      return result;
+    }
 
     function verifyTagFormat(tag: string) {
       var regex = /^v?\d+\.\d+\.\d+$/i;
@@ -57,5 +63,10 @@ export class LatestReleaseProvider {
         patch: +formattedNumber[2]
       };
     };
+
+    function setErrorAndReturn(errorMsg: string) {
+      result.error = errorMsg;
+      return result;
+    }
   };
 }