Ytukyg

I am very new to coding so please bear with me.


I am trying to write a test for this function:

redirect() {

        if (!this.userInfo || !this.userInfo.userId) {

            const originalPath = this.$location.path();

            if (originalPath === '/') {

                this.$location.path('/login');

            } else {

                this.$location.path('/login').search('redirect', originalPath);

            }

            return;

        }

This is my mock:

beforeEach(() => {

        mocks = {path: function () {return '/login';},

        search: function() {return 'redirect', 'fakepath'}};

        ctrl = new BxIndex(mocks);

    });

This is my test:

spyOn(ctrl.$location, 'path').and.returnValue(mocks);

spyOn(ctrl.$location, 'search').and.callThrough();

ctrl.redirect();

expect(ctrl.$location.search).toHaveBeenCalledWith('redirect', 'fakepath');

It fails because the second call is an object:

Expected spy search to have been called with [ 'redirect', 'fakepath' ] but actual calls were [ 'redirect', Object({ path: spy on path, search: spy on search }) ].

The simple answer to get around the problem with this particular test is to change this line:

//spyOn(ctrl.$location, 'path').and.returnValue(mocks);

spyOn(ctrl.$location, 'path').and.returnValue('fakepath');

Edit: Looking at the code being tested, it looks like ctrl.$location.path returns different results depending on how it's called. If it's called with no parameters, then it appears to return a string. If it's called with a string as the parameter, then it appears to return the ctrl.$location object itself. Assuming I'm correct on that, there are two options...

The first option is to just set up your ctrl object for the test so that ctrl.$location.path doesn't need to be mocked (spied) at all, if possible.

The second option is to implement the dual-return logic in your spy using callFake:

spyOn(ctrl.$location, 'path').and.callFake(function(arg) {

    if (typeof arg == "string") {

        return ctrl.$location;

    } else {

        return "fakepath";

    }

});

End Edit

But I think you're missing some details on how the spyOn functions work, so I will elaborate a little!

When you spy on a function, you're basically replacing that function with a spy - so if you subsequently call that function, it does nothing by default.
But you can add on to your spy too - for instance, you can have it return a specific value, or you can have it go ahead and call through to the original function that it is standing in for. That's what's happening when you use spyOn(...).and.returnValue() and spyOn(...).and.callThrough().

For example, let's say I have this simple object, foo. It has a function called sayHello, which calls another function called send, which sends a message over the network to Bob. If the message is sent successfully, the messagesToBob counter goes up by one, otherwise it remains the same. (send returns true if it worked, or false if it didn't).

// Begin contrived example!

var foo = {

    messagesToBob: 0,

    sayHello: function() {

        if (this.send()) {

            this.messagesToBob += 1;

        }

    },

    send: function() {

        network.send("Bob", "Hello");

    }

};

Now I want to test this, but obviously I don't want to be sending Bob a bunch of messages during my tests. So that's where the spy comes in.

spyOn(foo, "send");

This essentially takes the foo.send function and replaces it with an empty function (I believe it will just returned undefined).

If I want to test the foo increments the counter on a successful run, I can make the "send" spy return true:

spyOn(foo, "send").and.returnValue(true);

foo.sayHello();



expect(foo.messagesToBob).to.equal(1);

If I want to test that it does not increment on a failed send, I can make the "send" spy return false.

In any of those cases, I could also check the status of the spy function itself using the expect(...).toHaveBeenCalled() or .toHaveNotBeenCalled() (or whatever functions are available to your particular testing framework/environment).

Anyway, I hope that helps! Your "mock" object's functions don't need to return a value in this example (assuming you need that object at all), because those functions are being replaced with spies anyway.