rogerxu commented 8 years ago

rogerxu commented 8 years ago

Mocha and Jasmine are testing frameworks to test your code: they can use different assertion libraries, reporters, etc...
- Jasmine is a more complete all-in-one solution, shipping an assertion library with custom methods, callback spies support and more (as Jasmine 2.x).
- Mocha has the opposite approach: basic functionalities built-in and extensibility through plugins.
should.js is an assertion library - It works from IE9 onward and any other browser - so you need a testing framework to use it
chai is an assertion library "ecosystem": you can add plugins (I'm looking at you sinonJS) or just use it plain with its own version of should.js or expect.js - also here you need a testing framework in order to use it
karma is a testing environment that leverages the power of Mocha and Jasmine to test cross-browser, do E2E testing, and more

rogerxu commented 8 years ago

Karma

Karma is a browser test runner.

The idea is that browsers do not have natively a concept of loading tests files, running them, and reporting results. What karma does is (roughly) :

starting a small web server to serve "client-side" javascript files to be tested (1)
also serve the "client-side" javascript files with the tests (or Specs, as they're often called) (2)
serve a custom web page that will run javascript code for the tests (3)
start a browser to load this page (4)
report the results of the test to the server (5)
karma can then again report the results to text files, the console, anything your CI server likes, etc...

Looking at each part :

Those files will be your actual js files ; you will tell karma how to load them. If you use requirejs, there is a karma plugin, and some config is needed.
Those tests can be written in a variety of Javascript testing framework (Jasmine, QUnit, Mocha) ; this is JS code that is run in the browser.
The custom web page will be a bit different for each testing framework ; this is why karma has plugins for different frameworks.
Karma can launch the page in many browsers (FF, Chrome, or headless browsers like PhantomJs.)
Reporting to karma is, again, framework-dependant, and dealt with karma plugins.

So to answer your questions :

in Java, most people use JUnit which is both a framework to write tests and run them, but does not have the problem of differentiating the environment in which tests are run and the one in which test reports are aggregated ; karma would be the missing piece between a JUnit Suite and a JUnit TestRunner
Yes, you can do everything that karma does "by hand" - pick one framework (jasmine, qunit, mocha) and follow instructions. The advantage of karma is that it provide a solution out-of-the-box, if you're in a standard setup.
Karma can be used for both unit test (with jasmine / qunit / whatever) and integration tests (which will use another API, like webdriver, to drive the browser)

rogerxu commented 8 years ago

Jasmine vs. Mocha

rogerxu commented 7 years ago

rogerxu commented 7 years ago

yarn add --dev babel-cli
yarn add --dev isparta

babel-node ./node_modules/isparta/bin/isparta cover ./node_modules/mocha/bin/_mocha

package.json

{
  "scripts": {
    "coverage": "babel-node ./node_modules/isparta/bin/isparta cover ./node_modules/mocha/bin/_mocha"
  }
}

rogerxu commented 7 years ago

rogerxu commented 7 years ago

Unit tests ensure that individual components of the app work as expected.
Integration tests ensure that component collaborations work as expected.
Functional tests ensure that the app works as expected from the user's perspective. Assertions primarily test the user interface. (end-to-end tests)

rogerxu commented 6 years ago