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

# Jasmine
[Jasmine](https://jasmine.github.io/) is a framework for testing code in JavaScript. It’s a tool that:

* finds all test files (also known as specification, or spec, files).
* runs the tests.
* reports on the result: `ok`, `fail`, and `skip`.

Jasmine allows us to avoid the inconvenience of having our code and its tests in the same file. The test code isn’t beneficial to users, and we don’t want our users to see the console logs of our tests.

Run the code below to see an example of what Jasmine outputs.


React

Dart

GoJS React

Typescript React

Vue.js

# Breakdown

The `jasmine.json` file in the `spec/support` folder configures Jasmine.

The `src` is the folder to search for spec files.

The `"**/*[sS]pec.js" `is the [glob pattern] (https://en.wikipedia.org/wiki/Glob_(programming)) to match files and recognize them as tests, also know as `spec` files. This pattern can be translated to, “Hey, Jasmine, look for all files in the `src` folder that have names ending with `spec.js` or `Spec.js` and run the tests in them.” 

The result is that Jasmine runs `src/my.spec.js` and `src/deep/nested/another.spec.js` and skips `src/my.function.js`.

The spec files we’re using are `src/my-first.spec.js` and `src/deep/nested/another.spec.js`. The second of these demonstrates that deep nesting still matches the pattern.

The file `src/my-function.js` doesn’t match the spec pattern, so it’s skipped.

# Spec file

A spec file generally consists of the following:

* A `describe` container that names and holds a section of our test cases. It’s not unlike namespaces/modules in Node.js.

* An `it` container that names and holds the implementation of a single test case.

Looking at `src/my-first.spec.js`, the `describe` is a function that takes two parameters:

* The name, which is 'My first test' in this case.
* The function callback that houses the test cases.

![describe params image missing](/udata/zOMZdMG7zbw/what-is-describe.png)

An `it` is a single test case. It’s a function that takes two parameters:

* The name, which is `should run fine` in this case.
* The function, which is the test case implementation in the form of a function. In this case, it’s an arrow function that calls the `expect` function from Jasmine.
- ![it params image missing](/udata/X11OQQ9znDM/lesson-2.2-what-is-it.png)
Finally, the test case itself is only one `expect` call that translates to, “Make sure the string `fine` is equal to the string `fine`.”

> All this is just a demonstration test run. In reality, each test case likely contains more logic.

# Run

Running the above code should yield the following:

```sh
Started
..

2 specs, 0 failures
```

# Experiment

Experiment using the code playground above. Try changing the string on one side of the `expect` function and run the specs. For example, `expect('fsine').toEqual('fine');`. Notice now the failing test is reported in more detail.
- Try adding one more `it` test. For example:

  - ```js
    it('my second test', () => {
       expect('a string with spaces'.split(' ')).toEqual(['a', 'string', 'with', 'spaces'])
    });


Get introduced to Jasmine, and learn how it can run your tests.

Overview

Testing JavaScript with Jasmine

Testing Asynchronous Code

Debugging Jasmine Tests

Summary

Use Jasmine to Run Unit Tests

Jasmine