gaf-mobile/app/scripts/controllers/MembershipsCtrl.spec.js

GAF mobile Web site

'use strict';

/* global MembershipPackagesMock*/

describe('Controller: MembershipsCtrl', function() {
  var $rootScope, $scope, $q, $filter, $windowMock, $locationMock;
  var MembershipsMock, userMock, loggedInUserMock, currencyMock, packageMock,
    returnUrl;
  var createCtrl;

  beforeEach(module('gafMobileApp'));

  beforeEach(inject(function($controller, _$rootScope_, _$q_, _$filter_) {
    $rootScope = _$rootScope_;
    $scope = $rootScope.$new();
    $q = _$q_;
    $filter = _$filter_;

    currencyMock = {
      get: function() {
        return {
          id: 7,
          sign: '₱'
        };
      }
    };
    loggedInUserMock = {
      get: function() {
        return userMock;
      },
      getPrimaryCurrency: function() {
        return currencyMock;
      }
    };
    packageMock = MembershipPackagesMock()[0].packages[0]; // just get 1 package
    returnUrl = '/return/here';

    $locationMock = jasmine.createSpyObj('$location', ['search', 'url']);
    $locationMock.search.and.returnValue({ return: returnUrl });

    $windowMock = {
      location: {
        href: ''
      }
    };

    MembershipsMock = jasmine.createSpyObj('Memberships', ['getUpsellTrial',
      'getTrialPackages', 'subscribe']);
    MembershipsMock.getUpsellTrial.and.returnValue($q.when({
      get: function() { return packageMock; },
      getVisibleBenefits: function() { return []; }
    }));
    MembershipsMock.getTrialPackages.and.returnValue($q.when({
      getList: function() {
        return [{
          get: function() { return packageMock; },
          getVisibleBenefits: function() { return []; }
        }];
      }
    }));
    MembershipsMock.subscribe.and.returnValue($q.when({}));

    createCtrl = function() {
      return $controller('MembershipsCtrl', {
        $scope: $scope,
        $rootScope: $rootScope,
        $q: $q,
        $location: $locationMock,
        $window: $windowMock,
        $filter: $filter,
        Memberships: MembershipsMock,
        loggedInUser: loggedInUserMock
      });
    };
  }));

  describe('Setting up the return URL upon initialization', function() {
    it('should get it from location param if set', function() {
      var ctrl = createCtrl();
      expect(ctrl.returnUrl).toEqual(returnUrl);
    });

    it('should default to /dashboard if location param is not set', function() {
      $locationMock.search.and.returnValue({});
      var ctrl = createCtrl();
      expect(ctrl.returnUrl).toEqual('/dashboard');
    });
  });

  describe('Setting up the currency to use upon initialization', function() {
    it('should get the primary currency of the logged in user', function() {
      var ctrl = createCtrl();
      expect(ctrl.userCurrency).toEqual(currencyMock.get());
    });
  });

  describe('Setting up the upsell trial membership package', function() {
    describe('if service call returned a truthy value', function() {
      var ctrl;

      beforeEach(function() {
        ctrl = createCtrl();
        $scope.$digest();
      });

      it('should use the value returned by the service', function() {
        expect(ctrl.upsellTrial).toEqual(packageMock);
      });

      it('should set `isTrial` and `quantity` attributes to the upsell ' +
        'price object to be used in subscription', function() {
        expect(ctrl.upsellTrialPriceDetails).toBeDefined();
        expect(ctrl.upsellTrialPriceDetails.isTrial).toEqual(true);
        expect(ctrl.upsellTrialPriceDetails.quantity).toEqual(1);
      });
    });

    describe('if service call returned a falsy value', function() {
      var ctrl;

      beforeEach(function() {
        // MembershipsMock.getUpsellTrial.and.returnValue($q.reject(false));
        MembershipsMock.getTrialPackages.and.returnValue($q.reject(false));
        ctrl = createCtrl();
        $scope.$digest();
      });

      it('should be undefined', function() {
        expect(ctrl.upsellTrial).toEqual(undefined);
        expect(ctrl.upsellTrialPriceDetails).not.toBeDefined();
      });

      it('should set location to assigned return URL', function() {
        expect($locationMock.url).toHaveBeenCalledWith(returnUrl);
      });
    });
  });

  describe('Method: subscribe()', function() {
    it('should call service method to subscribe user if they are payment ' +
      'verified then redirect to assigned return URL', function() {
      userMock = {
        status: {
          payment_verified: true
        }
      };

      var priceDetails = {
        package_id: 123,
        duration: {
          type: 'month',
          cycle: 3
        },
        currency_id: 777,
        isTrial: true,
        quantity: 4
      };
      var params = {
        'currency': 777,
        'duration_cycle': 3,
        'is_trial': true,
        'quantity': 4,
        'auto_renew': true
      };

      var ctrl = createCtrl();

      ctrl.subscribe(priceDetails);
      $scope.$digest();

      expect(MembershipsMock.subscribe).toHaveBeenCalledWith(123, 'month',
        params);
      expect(ctrl.error.subscriptionError).not.toBeDefined();
      expect($windowMock.location.href).toEqual(returnUrl);
    });

    it('should redirect user to payment verification page if user has not ' +
      'yet verified a payment method', function() {
      userMock = {
        status: {
          payment_verified: false
        }
      };

      var paymentVerificationUrl = '/payments/verify' +
        '?return=/membership' +
        '&type=membership' +
        '&subtype=subscribe_trial' +
        '&membership=priceString';
      var priceDetails = {
        amount: null,
        duration: {
          type: null
        }
      };

      var ctrl = createCtrl();
      spyOn(ctrl, 'getPriceString').and.returnValue('priceString');
      
      ctrl.subscribe(priceDetails);
      
      expect($locationMock.url).toHaveBeenCalledWith(paymentVerificationUrl);
    });

    it('should show an error message if there were problems with the ' +
      'subscription request', function() {
      userMock = {
        status: {
          payment_verified: true
        }
      };

      var priceDetails = {
        package_id: 123,
        duration: {
          type: 'month',
          cycle: 3
        },
        currency_id: 777,
        isTrial: true,
        quantity: 4
      };

      MembershipsMock.subscribe.and.returnValue($q.reject({
        error_code: 500,
        data: {
          message: 'Internal error'
        }
      }));

      var ctrl = createCtrl();
      
      ctrl.subscribe(priceDetails);
      $scope.$digest();

      expect(ctrl.showUpsellTrialView).toEqual(true);
      expect(ctrl.error.subscriptionError).toEqual(true);
      expect(ctrl.error.internalError).toEqual('Internal error');
    });
  });

  describe('Method: getPriceString()', function() {
    it('should construct string using currency sign, code, amount, and ' +
      'duration', function() {
      var ctrl = createCtrl();
      var actualPriceString = ctrl.getPriceString('$', 'USD', 123, 'year');
      expect(actualPriceString).toEqual('$123.00 USD / year');
    });

    it('should construct string using currency sign, code, and amount only ' +
      'if duration is falsy', function() {
      var ctrl = createCtrl();
      var actualPriceString = ctrl.getPriceString('$', 'USD', 123);
      expect(actualPriceString).toEqual('$123.00 USD');
    });
  });

  describe('Method: getBenefitDisplayText()', function() {
    it('should return string starting with `Unlimited`', function() {
      var benefitObj = {
        benefit_value: -1,
        benefit: {
          display_name: 'Benefit name'
        }
      };
      var ctrl = createCtrl();
      var actualBenefitDisplayText = ctrl.getBenefitDisplayText(benefitObj);
      expect(actualBenefitDisplayText).toEqual('Unlimited Benefit name');
    });

    it('should only return the display name', function() {
      var benefitObj = {
        benefit_value: 1,
        benefit: {
          display_name: 'Benefit name'
        }
      };
      var ctrl = createCtrl();
      var actualBenefitDisplayText = ctrl.getBenefitDisplayText(benefitObj);
      expect(actualBenefitDisplayText).toEqual('Benefit name');
    });

    it('should return string starting with the benefit_value', function() {
      var benefitObj = {
        benefit_value: 111,
        benefit: {
          display_name: 'Benefit name'
        }
      };
      var ctrl = createCtrl();
      var actualBenefitDisplayText = ctrl.getBenefitDisplayText(benefitObj);
      expect(actualBenefitDisplayText).toEqual('111 Benefit name');
    });

    it('should return string starting with benefit.value', function() {
      var benefitObj = {
        benefit_value: null,
        benefit: {
          display_name: 'Benefit name',
          value: 999
        }
      };
      var ctrl = createCtrl();
      var actualBenefitDisplayText = ctrl.getBenefitDisplayText(benefitObj);
      expect(actualBenefitDisplayText).toEqual('999 Benefit name');
    });
  });

  describe('Behavior if URL has `verified=true` param', function() {
    it('should subscribe user given the price details of package to upsell',
      function() {
      $locationMock.search.and.returnValue({ verified: 'true' });
      var priceDetails = packageMock.prices[0];
      priceDetails.isTrial = true;
      priceDetails.quantity = 1;

      var ctrl = createCtrl();
      spyOn(ctrl, 'subscribe');
      $scope.$digest();
      
      expect(ctrl.subscribe).toHaveBeenCalledWith(priceDetails);
    });
  });

  describe('Determining whether to show upsell trial page or not', function() {
    it('should not show if there is no trial package to upsell', function() {
      // MembershipsMock.getUpsellTrial.and.returnValue($q.reject(false));
      MembershipsMock.getTrialPackages.and.returnValue($q.reject(false));
      var ctrl = createCtrl();
      $scope.$digest();
      expect(ctrl.showUpsellTrialView).toEqual(false);
    });

    it('should show only if there is a trial to upsell and `verified` ' +
      'param is falsy', function() {
      $locationMock.search.and.returnValue({ verified: null });
      var ctrl = createCtrl();
      $scope.$digest();
      expect(ctrl.showUpsellTrialView).toEqual(true);
    });
  });
});