Gain insights into testing functions and classes, mocking dependencies, naming tests, testing asynchronous code, Node.js code, and browser API-dependent code using Jasmine in your JavaScript app.

Using Jasmine to Unit Test Your JavaScript App.png

dockerfile.v6.tar.gz

Run jasmine

live Jasmine

Live jasmine in unit-testing-course folder

Run jasmine flat

Run jasmine --config=./jasmine.json

Once jasmine

Run jasmine-browser-runner console

Run jasmine-browser-runner console-copy

Run jasmine-browser-runner serve

Run jasmine-browser-runner serve 3000

This course will teach learners how to test functions and classes, mock dependencies, name the tests, test asynchronous code, test Node.js code, and test browser API-dependent code.

Using Jasmine to Unit Test Your JavaScript App

# The `maybeString` function
The function `maybeString` takes a parameter and a callback. It calls the callback only if the parameter is a string. The callback is the function that `maybeString` depends on for its logic.
```js
function maybeString(str, callback) {
  if (typeof str === 'string' && typeof callback === 'function') {
    return callback(str);
  }
}
```

The expression `typeof str === 'string' && typeof callback === 'function'` is `true` only if:
* The `str` parameter is actually a string and not `null` or `object` or `number`, and so on.
* The `callback` parameter is actually a `function` and not `null` or `object`, and so on.

If the above is true, the function returns the result of calling `callback` and passing str.

If the above is not true, our function returns `undefined`. This is because JavaScript considers any function that completes without hitting a `return` statement to have a return `undefined;` or `return;`  [MDN Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions#description).

# Mocking and spying

To be able to test `maybeString`, we need to provide the `callback` function. Instead of providing just any function, we’ll use a construct called spy. This is a function that monitors its calls and can give a specified response, or a mock function. Such a function takes the place of `callback`, and we can:

* Tell it what to return.
* Tell it to throw an error.

* Ask it how many times it was called and what parameters it was called with.

Run the code playground below for an example of testing a function using mocks.


React

Dart

GoJS React

Typescript React

Vue.js


The file `src/maybe-string.spec.js `contains the test cases for the `maybeString` function. Since that function accepts a callback and has logic that decides when to call that, the tests need to ensure that the callback is called when it’s supposed to and not otherwise.

## The spy

The expression `const spy = jasmine.createSpy('callback');` defines a constant of `spy` and assigns the return from `jasmine.createSpy`.

The method call `jasmine.createSpy('callback')` returns a spy. That’s a function with a couple special capabilities: properties and methods. First and foremost, this is a function just like any other in JavaScript. It accepts any number of parameters [arguments](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments). 

The spy capabilities include allowing expectations to be performed against the count and parameters of method calls:

* The expectation `expect(spy).toHaveBeenCalled()` verifies that the spy function is called.
* The expectation `expect(spy).toHaveBeenCalledTimes(1)` verifies that the spy function is called one time exactly. In this case, this could be used instead of the expectation above.
* The expectation `expect(spy).toHaveBeenCalledWith('s')` verifies that the spy function is called with an 's' parameter.
The expectation `expect(spy).toHaveBeenCalledWith('s', 1, 2)` can be used with multiple parameters too.

The called case verifies that `maybeString` calls the callback when it is supposed to. For example, there’s a `string` parameter and a `function `parameter. The spec is `it('should call the callback if string passed in', () => {`, and it utilizes the `toHaveBeenCalled...` expectations mentioned just above.


The not called case verifies that `maybeString` doesn’t call the callback when no `string` or `callback` is provided. It starts with creating a spy and calling the `maybeString` with non-string values as the first parameter. Then, it uses `.not` after the expectation, negating the expectations after it. That is, `expect(spy).not.toHaveBeenCalled();` verifies that spy is not called due to the `maybeString` calls with non-string values.

There is another case we should verify, and that is when the first parameter is indeed a `string`, but the second is not a `function`—for example, `maybeString('string', null)`. For this case, we can’t use a `spy` since the null value can’t be spied upon. So, to verify the expectation, we can use the result of the function. Namely, we expect that `undefined` is returned when no callback is passed in.


# Green path exercise

The green path is left as an exercise. Verify that when both the `str` and `callback` parameters are passed in and meet expectations, then the function returns the result of the `callback(str)` expression.

# The 'config' function

Sometimes a function receives an object as a parameter and uses a method from that object.

For example:

```js
function config(configObj) {
  if (configObj && typeof configObj.configure === 'function') {
    configObj = configObj.configure(configObj);
  }

  return configObj;
}
```

A `config` function receives an object, `configObj`, that may or may not have a `configure` attached function (also known as a method). That function then returns the configured object for use. This is a pattern used in JavaScript libraries.

How do we go about testing such a function?


# The `spyOn` function

The `spyOn` function is a globally-available Jasmine function. It takes an object as a first parameter. It also takes a method name, for which it will create and install a spy function. The spy function replaces the original and serves as a proxy for it, allows us to configure the return value, and keeps track of calls and parameters.

```js
const object = {
   myFunction: () => {....}
}

spyOn(object,  'myFunction')
```

Now, the `object` can be passed as a parameter to the function under test. It can then be used to ascertain that a call was made and if it was made using a specific set of parameters.

See `src/config.spec.js` in the code playground below for a working example.

Learn to test functions that take other functions as parameters and depend on them..

Overview

Testing JavaScript with Jasmine

Testing Asynchronous Code

Debugging Jasmine Tests

Summary

Test a Function Depending on Other Functions

The `maybeString` function

Mocking and spying

The spy

Test a Function Depending on Other Functions

The maybeString function

Mocking and spying

The spy

The `maybeString` function