qunit updated #660
Closed
qunit updated #660
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
Qunit updated to latest version |
|
@ram690514 I have now been able to run the tests on a separate PR, but they are still failing. You may be able to have a look here to diagnose: https://travis-ci.com/github/kiwix/kiwix-js/builds/191139336 I've included a screenshot below in case that link doesn't work for you. You can see that the very first assertion is failing. I recommend you run the tests manually in your implementation by going to your equivalent of http://localhost/Repos/kiwix-js/tests.html in a browser. You can then fully diagnose with your dev tools and fix errors.
|
|
I will surely work on it and I will fix it as soon as possible.Thank you,
for showing me up
…On Tue, Oct 20, 2020 at 3:07 PM Jaifroid ***@***.***> wrote:
@ram690514 <https://github.com/ram690514> I have now been able to run the
tests on a separate PR, but they are still failing. You may be able to have
a look here to diagnose:
https://travis-ci.com/github/kiwix/kiwix-js/builds/191139336
I've included a screenshot below in case that link doesn't work for you.
You can see that the very first assertion is failing. I recommend you run
the tests manually in your implementation by going to your equivalent of
http://localhost/Repos/kiwix-js/tests.html in a browser. You can then
fully diagnose with your dev tools and fix errors.
[image: image]
<https://user-images.githubusercontent.com/4304337/96568439-dd8d2380-12bf-11eb-991b-bfcd0ff6c925.png>
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
<#660 (comment)>, or
unsubscribe
<https://github.com/notifications/unsubscribe-auth/ARAWVBVE5UKBOQXUTXWRRADSLVK6DANCNFSM4SXVQI6Q>
.
|
Closed
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Nov 22, 2020
* Load qunit package from npm. Start of a larger transition, ref kiwix#554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to run a QUnit web page with Nightwatch, this was not ideal. This had numerous limitations, such as: - relies on fragile an unsupported web scraping to collect results, which can easily break between versions. ref kiwix#660. - results provide limited debugging information when a test fails. - cannot easily be run locally from the command-line since the Nightwatch config is currently written for SauceLabs, and creating a local configuration is not easy because Nightwatch has a hard requirement on webdriver (which makes sense for UI tests), which people usually do not have installed or may be incompatible with the current version of their browser. These then also have to be configured and started etc. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. * Using Karma means: - You can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact runner is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests from within there without exposing anything from your personal computer, except the current working directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, and then submit this to Codecov or Coveralls, ref kiwix#528. * I have restructured the Travis CI file so that the cross-browser test in SauceLabs are skipped for PRs from forks. Instead, those PRs will run the unit tests in local Fireox and Chrome within Travis CI. This avoids the confusing failures and still gives (some) useful results. The tests that Travis CI runs are the same as what users can run locally if they invoke `npm test` (after a one-time run of `npm install` to fetch dependencies into the local node_modules directory). This restructuring uses the 'stages' feature which is not compatible with the 'deploy' feature. I had converted the two deploy stages to use the 'stages' feature as well so that these continue to work. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently switch major versions that may contain breaking changes. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Nov 28, 2020
* Load qunit package from npm. Start of a larger transition, ref kiwix#554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to run a QUnit web page with Nightwatch, this was not ideal. This had numerous limitations, such as: - relies on fragile an unsupported web scraping to collect results, which can easily break between versions. ref kiwix#660. - results provide limited debugging information when a test fails. - cannot easily be run locally from the command-line since the Nightwatch config is currently written for SauceLabs, and creating a local configuration is not easy because Nightwatch has a hard requirement on webdriver (which makes sense for UI tests), which people usually do not have installed or may be incompatible with the current version of their browser. These then also have to be configured and started etc. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. * Using Karma means: - You can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact runner is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests from within there without exposing anything from your personal computer, except the current working directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, and then submit this to Codecov or Coveralls, ref kiwix#528. * I have restructured the Travis CI file so that the cross-browser test in SauceLabs are skipped for PRs from forks. Instead, those PRs will run the unit tests in local Fireox and Chrome within Travis CI. This avoids the confusing failures and still gives (some) useful results. The tests that Travis CI runs are the same as what users can run locally if they invoke `npm test` (after a one-time run of `npm install` to fetch dependencies into the local node_modules directory). This restructuring uses the 'stages' feature which is not compatible with the 'deploy' feature. I had converted the two deploy stages to use the 'stages' feature as well so that these continue to work. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently switch major versions that may contain breaking changes. Fixes kiwix#653.
Krinkle
added a commit
that referenced
this pull request
Nov 28, 2020
* Load qunit package from npm. Start of a larger transition, ref #554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to run a QUnit web page with Nightwatch, this was not ideal. This had numerous limitations, such as: - relies on fragile an unsupported web scraping to collect results, which can easily break between versions. ref #660. - results provide limited debugging information when a test fails. - cannot easily be run locally from the command-line since the Nightwatch config is currently written for SauceLabs, and creating a local configuration is not easy because Nightwatch has a hard requirement on webdriver (which makes sense for UI tests), which people usually do not have installed or may be incompatible with the current version of their browser. These then also have to be configured and started etc. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. * Using Karma means: - You can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact runner is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests from within there without exposing anything from your personal computer, except the current working directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, and then submit this to Codecov or Coveralls, ref #528. * I have restructured the Travis CI file so that the cross-browser test in SauceLabs are skipped for PRs from forks. Instead, those PRs will run the unit tests in local Fireox and Chrome within Travis CI. This avoids the confusing failures and still gives (some) useful results. The tests that Travis CI runs are the same as what users can run locally if they invoke `npm test` (after a one-time run of `npm install` to fetch dependencies into the local node_modules directory). This restructuring uses the 'stages' feature which is not compatible with the 'deploy' feature. I had converted the two deploy stages to use the 'stages' feature as well so that these continue to work. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently switch major versions that may contain breaking changes. Fixes #653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 28, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.12. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.13. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.13. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.13. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.13. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.13. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 29, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.13. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on the fragile and unsupported DOM scraping to collect results, which breaks between versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be run or debugged locally from the command-line since as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server first. People usually do not have this installed and is hard to set up. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes kiwix#653.
Krinkle
added a commit
to Krinkle/kiwix-js
that referenced
this pull request
Dec 30, 2020
* Load qunit package from npm, this is the start of a larger transition. ref at kiwix#554. * Update QUnit from 2.3 to 2.13. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on fragile and unsupported DOM scraping to collect test results, which breaks between framework versions. ref kiwix#660. - severely limits debugging information for failing tests. - cannot easily be reproduced or debugged locally from the command-line as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server. People usually do not have this installed and it's non-trivial to set up and keep working in the long term, and across multiple different software projects. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref kiwix#528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support.
mossroy
pushed a commit
that referenced
this pull request
Jan 3, 2021
* workflows: Rename "CI" to "Release" Rename this to make space for a separate "CI" workflow that will run continuous integration and testing jobs for commits and PRs. * workflows: add CI workflow for unit tests and support running locally * Load qunit package from npm, this is the start of a larger transition. ref at #554. * Update QUnit from 2.3 to 2.13. * Use Karma for the running of unit tests (instead of Nightwatch). While it was possible to use a fake "UI" test to open the QUnit web page with Nightwatch, this had numerous limitations: - relies on fragile and unsupported DOM scraping to collect test results, which breaks between framework versions. ref #660. - severely limits debugging information for failing tests. - cannot easily be reproduced or debugged locally from the command-line as the Nightwatch config was pinned to Sauce Labs, and creating a local configuration is not easy because Nightwatch has a hard requirement for installing and running a WebDriver server. People usually do not have this installed and it's non-trivial to set up and keep working in the long term, and across multiple different software projects. - cannot easily be run in a secure container separate from your personal computer, thus putting personal data at risk. - lacks wider integration and plugins to enrich unit testing, such as test coverage reports. Using Karma means: - We can run 'npm test' locally during development and have it automatically run the tests in headless Firefox and Chrome and report back, all from the command-line. - The same exact same stack is also used in CI with SauceLabs for additional browser coverage (same as before). - It has no external dependencies other than the plain web browser itself. This means if you have a development container (e.g. based on Docker) that has Node.js + Firefox + Chromium, you can run the tests there without exposing anything from your personal computer, besides the current directory. <https://timotijhof.net/posts/2019/protect-yourself-from-npm/> - In a future change, we can plug in karma-coverage to generate a test coverage report, to submit to Codecov or Coveralls. ref #528. * I have pinned the version of 'http-server' and 'nightwatch' in package.json so that these don't silently upgrade in a way that may introduce security issues or drop compatibility for the environment we currently support. Fixes #653. * Re-enable unit and UI tests in latest Edge The tests were disabled after #499 due to an issue with the Edge version that was the default "edge" on SauceLabs in May 2019 (not sure which version that was, the last pre-Chromium Edge version was 44, which was passing, so perhaps SauceLabs defaulted to a beta release, or used a much older version like 15-18?) Now that Edge uses Chromium, try re-enabling the tests. Fixes #502.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
qunit updated to latest version 2.11.3