Test Driven Development using QUnit

Test Driven Development
(TDD) using QUnit
By Satej Kumar Sahu
Mindfire Solutions

Contents
• What is TDD?
• A look into BDD
• Real life example
• TDD concepts
• What is QUnit?
• QUnit API sample use cases with examples
• TDD using unit tests with QUnit
• Conclusion

Simple Testing
• What is Testing?
• Who does it? Is it solely confined as a role of QA?
• Sometimes gives you a feeling of being Sherlock Holmes (The famous detective you know) in a
mystery.
• Some examples of simple testing may include:
- Manual browser testing
- Echo, exit testing
- Debug tools like xDebug, IDE integrated debugging, breakpoints etc.
• Pros:
- Simple, easy to debug methods and tools.
- Sometimes and in some ways are quick in showing results.
• Cons:
- Does not cover every aspect.
- Time taking and risk prone.
- Monotonous and repetitive.
- In long term, not productive.

What is TDD?
• Test Driven Development
• It’s a practice that embodies a test first methodology.
• In either real world or the virtual world, in software
industry or any other industry, TDD can / is being
followed. Building a house or a room. Seminar
planning.
• You have requirements or cases or stories for a
project. With TDD, you first start from writing test cases
for requirements and then followup with development
code to pass those test cases.

A look into BDD
• In contrast to TDD, BDD is when we write behaviour & specification that
then drives our software development.
• Behaviour & specification might seem awfully similar to tests but the
difference is very subtle and important.
• The main difference is just the wording. BDD uses a more verbose style so
that it can be read almost like a sentence.
• The ability to read your tests like a sentence is a cognitive shift in how you
will think about your tests. The argument is that if you can read your tests
fluidly, you will naturally write better and more comprehensive tests.
• BDD tests should be more focused on the features, not the actual results.
• https://github.com/joshuaclayton/specit

Real life example
• As the saying goes for a tailor “Measure twice, cut once”
• A Tailor -> Software Developer
• Notes the cloth requirement -> Project requirement
• Starts with measurement, prototypes using sketches,
software models -> Test cases
• Starts cutting cloth with every minute precision of
measurement being compared with tools against
specifications -> Code development and running test
cases reiteration.

TDD concepts
• Steps of TDD:
- Test first
- “Make it run”
- Refactor / Make it better.
• Refactoring: Act of restructuring, rewriting, renaming and removing code in order to improve:
- Design
- Readability
- Maintainability
• 3 A’s of Unit Testing:
- Assemble
- Act
- Assert
• Unit Test: Focus is on individual components.
• From unit tests, one can proceed on to end to end testing where focus is on complete
behaviour of a feature.

• A simple test case written using console.log
• Need of unit test frameworks for testing
• Provide tools and APIs to test.
• A framework that provides a test runner, as well
as some utilities to write the actual tests.

What is QUnit?
• QUnit is a powerful, easy-to-use JavaScript unit
testing framework.
• It's used by the jQuery, jQuery UI and jQuery
Mobile projects and is capable of testing any
generic JavaScript code, including itself!
• http://qunitjs.com/

QUnit user interface and it's
various parts.

QUnit API sample use cases
with examples
• ok( truthy [, message ] )
• equal( actual, expected [, message ] )
• strictEqual()
• deepEqual( actual, expected [, message ] )
• expect() -> testing callbacks
• async()
• QUnit.module()

TDD using unit tests
with QUnit

• Advantages:
- Your application is test covered.
- Customers, clients and developers are more
confident about their application robustness.
- Tests are automated. You just need to run it. Can
be part of a CI process.
- Productivity increases.
- You implement features and fixes without worrying
about what you have broken.
- Testing can also drive the design of software. Unit
block codes are present and are decoupled and
independent. TDD thinking helps in better API
design.
- It acts as a documentation for your application.

Some practical use cases of
QUnit
• https://github.com/jquery/jquery/tree/master/test/unit
• https://github.com/jquery/jquery-ui/tree/master/tests/unit
• https://github.com/jzaefferer/jquery-validation/tree/master/te

References
• http://hubpages.com/business/Test-First-A-Real-Life-Ex
• http://qunitjs.com/
• http://qunitjs.com/cookbook/
• http://qunitjs.com/plugins/

Test Driven Development using QUnit

More Related Content

What's hot (20)

Similar to Test Driven Development using QUnit (20)

Recently uploaded (20)

Test Driven Development using QUnit