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

GAF mobile Web site

'use strict';

describe('Controller: UpgradeProjectCtrl', function() {

  // Vars
  var $scope, $q, $location, $httpBackend, createCtrl;

  // Mocks
  var RouteMock, ProjectsMock, CookieStoreMock, AnalyticsMock;

  var projectFees = {
    assisted_price: 11.1,
    extend_price: 22.2,
    featured_price: 33.3,
    fulltime_price: 44.4,
    nda_price: 55.5,
    nonpublic_price: 66.6,
    sealed_price: 77.7,
    urgent_price: 88.8,

    currency: {
      code: 'BTC',
      name: 'Bitcoin',
      country: 'BC',
      sign: '=B=',
      exchange_rate: 1.0,
      id: 42
    },

    free_extend: false,
    free_hidden_bids: false,
    free_nda: false
  };

  var projectData = {
    id: 1,
    title: 'E-box design cover for $20-$50 budget.',
    seo_url: 'Photoshop/box-design-cover-for-budget'
  };

  // Load the controller's module
  beforeEach(module('gafMobileApp'));

  // Initialize the controller
  beforeEach(inject(function($controller, _$rootScope_, _$q_, _$location_,
    _$httpBackend_) {
    $scope = _$rootScope_.$new();
    $q = _$q_;
    $location = _$location_;
    $httpBackend = _$httpBackend_;
    // Controller constructer to enable to tweak the
    // mock ups before instantiate it
    createCtrl = function() {
      return $controller('UpgradeProjectCtrl', {
        $scope: $scope,
        $location: $location,
        $route: RouteMock,
        Projects: ProjectsMock,
        CookieStore: CookieStoreMock,
        Analytics: AnalyticsMock
      });
    };
  }));

  // Create the mock ups
  beforeEach(function() {
    ProjectsMock = jasmine.createSpyObj('ProjectsMock', ['getCurrent',
                                        'setCurrent']);
    ProjectsMock.getCurrent.and.returnValue({
      get: function() {
        return projectData;
      },
      upgrade: jasmine.createSpy(),
      isOwner: function() {
        return true;
      }
    });

    RouteMock = { current: { locals: {
      projectBundle: {
        get: function() {
          return projectFees;
        }
      }}
    }};

    CookieStoreMock = jasmine.createSpyObj('CookieStoreMock', ['remove',
                                           'put', 'get']);

    AnalyticsMock = jasmine.createSpyObj('Analytics', ['trackAction',
                                        'trackError']);

    $httpBackend.when('GET', '/views/main.html').respond({});
  });

  it('should redirect to error page if accessed by not owner',
  function() {
    ProjectsMock.getCurrent.and.returnValue({
      isOwner: function() {
        return false;
      }
    });
    createCtrl(); 
    expect($location.url()).toEqual('/error');
  });

  it('should get the currently loaded project to upgrade',
  function() {
    var ctrl = createCtrl();
    expect(ctrl.project.get()).toEqual(projectData);
  });

  it('should set vars correctly upon page load',
  function() {
    var ctrl = createCtrl();
    expect(ctrl.showAllUpgrades).toEqual(false);
    expect(ctrl.error).toEqual({});
    expect(ctrl.upgrades).toEqual({});
  });

  it('should set default view state to upgrade project',
  function() {
    var ctrl = createCtrl();
    expect(ProjectsMock.getCurrent).toHaveBeenCalled();
    expect(ctrl.viewState).toEqual('upgradeProject');
  });

  it('should load project fees for the current user',
  function() {
    var ctrl = createCtrl();
    expect(ctrl.projectFees).toEqual(projectFees);
  });

  it('should show confirm modal and load upgrades when coming from deposit',
  function() {
    CookieStoreMock.get.and.returnValue('assisted,nda');
    $location.url('/upgrade-project/1?deposit=success');
    var ctrl = createCtrl();

    expect(ctrl.upgrades).toEqual({ assisted: true, nda: true });
    expect(ctrl.viewState).toBe('confirmUpgrade');
  });

  it('should show upgrades when coming from deposit and cannot load stored ' +
    'project upgrades', function() {
    CookieStoreMock.get.and.returnValue(null);
    $location.url('/upgrade-project/1?deposit=success');
    var ctrl = createCtrl();

    expect(ctrl.upgrades).toEqual({});
    expect(ctrl.viewState).toBe('upgradeProject');
  });

  it('should check whether project came from PPP or PVP', function() {
    CookieStoreMock.get.and.returnValue(null);
    $location.url('/upgrade-project/1#newproject');
    var ctrl = createCtrl();

    expect(ctrl.newProject).toBeTruthy();
  });

  describe('Method: calculateTotal()', function() {
    var expected;
    var ctrl;

    beforeEach(function() {
      expected = 0;
      ctrl = createCtrl();
    });

    it('should return zero total of no upgrades selected', function() {
      expect(ctrl.calculateTotal()).toBe(expected);
    });

    it('should calculate correct total fee when all upgrades selected',
    function() {
      expected = projectFees.assisted_price + projectFees.extend_price +
        projectFees.featured_price + projectFees.fulltime_price +
        projectFees.nda_price + projectFees.nonpublic_price +
        projectFees.sealed_price + projectFees.urgent_price;

      ctrl.upgrades = {
        assisted: true,
        extend: true,
        featured: true,
        fulltime: true,
        nda: true,
        nonpublic: true,
        sealed: true,
        urgent: true
      };
      expect(ctrl.calculateTotal()).toEqual(expected);
    });

    it('should calculate correct fee when some upgrades selected', function() {
      expected = ctrl.projectFees.assisted_price +
        ctrl.projectFees.extend_price +
        ctrl.projectFees.featured_price +
        ctrl.projectFees.sealed_price +
        ctrl.projectFees.nonpublic_price +
        ctrl.projectFees.urgent_price;

      angular.extend(ctrl.upgrades, {
        assisted: true,
        extend: true,
        featured: true,
        sealed: true,
        nonpublic: true,
        urgent: true
      });

      expect(ctrl.calculateTotal()).toBe(expected);
    });

    it('should not include upgrade fee when unset', function() {
      expected = ctrl.projectFees.assisted_price +
        ctrl.projectFees.extend_price +
        ctrl.projectFees.featured_price +
        ctrl.projectFees.sealed_price +
        ctrl.projectFees.nonpublic_price +
        ctrl.projectFees.urgent_price;

      angular.extend(ctrl.upgrades, {
        assisted: true,
        extend: true,
        featured: true,
        sealed: true,
        nonpublic: true,
        urgent: true,
        nda: false
      });

      expect(ctrl.calculateTotal()).toBe(expected);
    });

    it('should return total of the upgrades selected accounting for free '+
      'hidden bids', function() {
      ctrl.upgrades.sealed = true;
      ctrl.projectFees.free_sealed = true;
      expect(ctrl.calculateTotal()).toBe(expected);

      ctrl.projectFees.free_sealed = false;
      expected = ctrl.projectFees.sealed_price;
      expect(ctrl.calculateTotal()).toBe(expected);
    });

    it('should return total of the upgrades selected accounting for free '+
      'extend', function() {
      ctrl.upgrades.extend = true;
      ctrl.projectFees.free_extend = true;
      expect(ctrl.calculateTotal()).toBe(expected);

      ctrl.projectFees.free_extend = false;
      expected = ctrl.projectFees.extend_price;
      expect(ctrl.calculateTotal()).toBe(expected);
    });

    it('should return total of the upgrades selected accounting for free '+
      'nda', function() {
      ctrl.upgrades.nda = true;
      ctrl.projectFees.free_nda = true;
      expect(ctrl.calculateTotal()).toBe(expected);

      ctrl.projectFees.free_nda = false;
      expected = ctrl.projectFees.nda_price;
      expect(ctrl.calculateTotal()).toBe(expected);
    });

    it('should return zero total for undefined upgrades', function() {
      ctrl.upgrades.random = true;
      expect(ctrl.calculateTotal()).toBe(expected);
    });
  });

  describe('Method: isUpgradeChecked()', function() {
    var ctrl;

    beforeEach(function() {
      ctrl = createCtrl();
    });

    it('should return false if no upgrade selected', function() {
      ctrl.upgrades.nda = false;

      expect(ctrl.isUpgradeChecked()).toBe(false);
    });

    it('should return true if one upgrade selected', function() {
      ctrl.upgrades.nda = true;

      expect(ctrl.isUpgradeChecked()).toBe(true);
    });

    it('should return false by default', function() {
      ctrl.upgrades = {};

      expect(ctrl.isUpgradeChecked()).toBe(false);
    });
  });

  describe('Method: upgrade()', function() {
    var ctrl, currentProject;
    var cookieName = 'project_upgrades';

    beforeEach(function() {
      ctrl = createCtrl();
      currentProject = ProjectsMock.getCurrent();
    });

    it('should upgrade successfully with free upgrades', function() {
      currentProject.upgrade.and.returnValue($q.when({
        status: 'success'
      }));
      ctrl.upgrades.extend = true;
      ctrl.upgrades.hidebids = false;
      ctrl.projectFees.free_extend = true;
      ctrl.projectFees.free_hidden_bids = false;
      ctrl.upgrade(ctrl.upgrades);
      $scope.$digest();

      expect(currentProject.upgrade).toHaveBeenCalledWith(['EXTEND']);
      expect($location.path()).toEqual('/projects/' + projectData.seo_url);
    });

    it('should show error server message on upgrade failure', function() {
      currentProject.upgrade.and.returnValue($q.reject({
        error_code: 'INTERNAL_ERROR',
        message: 'Internal Error'
      }));
      ctrl.upgrades.extend = true;
      ctrl.projectFees.free_extend = true;
      ctrl.upgrade(ctrl.upgrades);
      $scope.$digest();

      expect(ctrl.error.unknownError).toBe(true);
      expect(ctrl.error.message).toBe('Internal Error');
    });

    it('should show unknown error message when response status is not success',
      function() {
      currentProject.upgrade.and.returnValue($q.when({
        status: 'error'
      }));
      ctrl.upgrades.extend = true;
      ctrl.projectFees.free_extend = true;
      ctrl.upgrade(ctrl.upgrades);
      $scope.$digest();

      expect(ctrl.error.unknownError).toBe(true);
    });

    it('should proceed to deposit page if insufficient funds', function() {
      currentProject.upgrade.and.returnValue($q.reject({
        error_code: 'ProjectExceptionCodes.PROJECT_UPGRADE_INSUFFICIENT_FUNDS'
      }));
      ctrl.upgrades.assisted = true;
      ctrl.upgrade(ctrl.upgrades);
      $scope.$digest();

      expect($location.url()).toBe('/deposit?type=upgrade&action=upgrade' + 
        '&amount=' + projectFees.assisted_price + '&project=' + projectData.id +
        '&currency=' + projectFees.currency.id);
    });

    it('should store selected upgrades when insufficient funds', function() {
      currentProject.upgrade.and.returnValue($q.reject({
        error_code: 'ProjectExceptionCodes.PROJECT_UPGRADE_INSUFFICIENT_FUNDS'
      }));
      ctrl.upgrades.assisted = true;
      ctrl.upgrades.extend = false;
      ctrl.upgrade(ctrl.upgrades);
      $scope.$digest();

      expect(CookieStoreMock.remove).toHaveBeenCalledWith(cookieName);
      expect(CookieStoreMock.put).toHaveBeenCalledWith(cookieName,
        ['assisted']);
    });
  });
});