Unit testing function, how to implement call to mock object

Preface: I am not well versed with Parse.js (nor jasmine for that matter)

I would recommend you go and grab sinonjs - super effective and (after some time) easy to use for mocking/stubbing/spying.

Start off by not worrying about the internal implementation of the Parse object, we're only interested in input and output of our dependencies when in a unit testing setting. There should be no reason to stub out a service object in that fine grade detail.

beforeEach

var $scope, Parse, createController;

beforeEach(function () {
  Parse = {};

  module('your_module', function ($provide) {
    // Provide "Parse" as a value in your module.
    $provide.value('Parse', Parse);
  });

  inject(function ($controller, $injector) {
    $scope = $injector.get('$rootScope').$new();
    Parse  = $injector.get('Parse'); // equal to: {} (at this point)

    createController = function () {
      return $controller('LoginCtrl', {
        $scope: $scope,
        Parse:  Parse
      });
    };
  });

  Parse.user = {};
  Parse.user.login = sinon.stub();
});

Parse is now entirely stubbed out. It will be an empty object that is then provided to the module, exposed in our spec, injected into our controller and then decorated with stubbed out methods matching those of the actual implementation (only by name, of course).

expectation(s)

What you should be testing in your controller spec, is not the internal behaviour of the Parse service, but rather that your controller is calling the methods of Parse with the correct parameters.

After that, you can go on to test what your controller, and its associated $scope does in reaction to the Parse.user.login() response.

it's

Note: I am writing these specs with the mocha/chai syntax - adopt the jasmine style as you see fit (not sure how it plays with sinon.js to be quite honest)

it('calls the Parse method', function () {
  createController();

  $scope.login('username', 'pw', angular.noop);

  expect(Parse.user.login).to.have
    .been.calledOnce.and.calledWith('username', 'pw', angular.noop);
});

context('Parse response', function () {
  it('failed', function () {
    Parse.user.login.returns({ status: 'super_error' });

    createController();

    $scope.login('a', 'b', angular.noop);

    expect(/* expect that something on $scope happened? */);
  });

  it('was succesful', function () {
    Parse.user.login.returns({ status: 'great_success', data: {} });

    createController();

    $scope.login('a', 'b', angular.noop);

    expect(/* expect that something on $scope happened? */);
  });
});

That is how I would write it. But - looking at the Parse.user.logIn docs we can see that the method returns a promise.

As such, you will need to take the following steps to effectively stub out the correct behaviour:

var $q; 

// combine this beforeEach block with the first one we wrote. 
beforeEach(function () {
  inject(function ($injector) {
    $q = $injector.get('$q');
  });
});

context('parse.user.login', inject(function ($timeout) {
  var success, error, opts;

  beforeEach(function () {
    success = sinon.stub();
    error   = sinon.stub();

    opts = {
      success: success,
      error:   error
    };
  });

  it('failed', function () {
    Parse.user.logIn.returns($q.reject({ status: 'bad_error' });
    createController();

    $scope.login('a', 'b', opts);
    $timeout.flush(); // Either this, or $rootScope.$digest or .notify(done) to flush the promise.

    expect(error).to.have.been.calledOnce;
  });

  it('was successful', function () {
    Parse.user.logIn.returns($q.when({ status: 'yay!', data: {} });
    createController();

    $scope.login('a', 'b', opts);
    $timeout.flush(); // Either this, or $rootScope.$digest or .notify(done) to flush the promise.

    expect(success).to.have.been.calledOnce;  
  });
}));