Software testing code coverage tutorials and videos

Well Tested Software

Software Testing Magazine — Mon, 11 Feb 2019 15:29:56 +0000

Software Testing is hard. Realistic testing of web applications in a real browser is even harder. In this video, Gleb Bahmutov shows you how to quickly test any web application using cutting-edge tools. Then you will see how to build high-quality software from individual modules using appropriate tools and creating an environment where bugs can be discovered immediately and fixed quickly. This session provides tremendous value for anyone programming in JavaScript or building modern web applications. You will learn how to: * How to write realistic end-to-end tests for any web application * How to run your tests quickly in several environments: local, staging, production * What is the ratio between unit and end-to-end tests * The role of code coverage, and how it might be misleading Video producer: http://oredev.org/ Session slides: https://slides.com/bahmutov/well-tested-software#/

The post Well Tested Software first appeared on Software Testing Magazine.

Improve Software Testing with Relevant Code Coverage

Software Testing Magazine — Mon, 03 Apr 2017 14:11:11 +0000

Code coverage is a software testing metric that measures the degree to which the source code of a program is tested by a particular test suite. This metrics is often difficult to understand and interpret for software development teams. In this article, Eran Sher proposes a better approach to code coverage that is more adapted to the current situation of continuous delivery and service architecture. Author: Eran Sher, SeaLights, https://www.sealights.io/ Technically, the term coverage relates to code coverage and is normally applied to unit tests. In reality, quality assurance (QA) teams emphasize two additional coverage metrics: * Functional coverage, as a percent of a feature/ requirement. * Test coverage, pass, fail and skip (a more apt name for this would be execution status). These interpretations of coverage are important and add value to understanding risk and quality. However, they are painfully out of sync with Continuous Delivery in general, and specifically out of sync with the evolving role of QA departments. With Continuous Delivery becoming a de facto standard, testing is changing fundamentally. As we shift from the manual to the automated, the makeup of QA departments is evolving from massive, distributed teams of testers with little or no technical skills to small, focused teams of engineer/ developer testers. This new breed of tester brings with him an architect’s perspective and is focused no more on the execution of tests but on their automation. QA teams are now made up of developer testers, and they need metrics that help them [...]

The post Improve Software Testing with Relevant Code Coverage first appeared on Software Testing Magazine.

Rescue Your Tests with Mutation Testing

Software Testing Magazine — Wed, 01 Feb 2017 13:19:43 +0000

Unit testing ensures your production code is relevant. But what does ensure your testing code is relevant? Come discover mutation testing and make sure your never forget another assert again. In the realm of testing, the code coverage metrics is the most often talked about. However, it doesn’t mean that the test has been useful or even that an assert has been coded. Mutation testing is a strategy to make sure that the test code is relevant. This talk explains how Code Coverage is computed and what its inherent flaw is. Afterwards, I describes how Mutation Testing works and how it helps pointing out code that is tested but leave out corner cases. Video producer: http://itakeunconf.com/ Slides of the presentation: http://itakeunconf.com/wp-content/uploads/2016/05/Mutation-Testing-to-the-rescue-of-your-tests.pdf

The post Rescue Your Tests with Mutation Testing first appeared on Software Testing Magazine.

Testing in Production at Netflix

Software Testing Magazine — Thu, 09 Apr 2015 14:51:56 +0000

Every day, Netflix has more customers consuming more content on an increasing number of client devices. We’re also constantly innovating to improve our customers’ experience. Testing in such a rapidly changing environment is a huge challenge, and we’ve concluded that running tests in our production environment can often be the most efficient way to validate those changes. This talk covers three test methods that we use in production: simulating all kinds of outages with the Simian Army, looking for regressions using canaries, and measuring test effectiveness with code coverage analysis from production.

The post Testing in Production at Netflix first appeared on Software Testing Magazine.

What Makes a Good Test Suite?

Software Testing Magazine — Thu, 12 Feb 2015 17:16:32 +0000

We all want “better” test suites. But what makes for a good test suite? Certainly, test suites ought to aim for good coverage, at least at the statement coverage level. To be useful, test suites should run quickly enough to provide timely feedback. This talk investigates a number of other dimensions on which to evaluate test suites. The talk claims that better test suites are more maintainable, more usable (for instance, because they run faster, or use fewer resources), and have fewer unjustified failures. This talk presents and synthesize facts about 10 open-source test suites (from 8,000 to 246,000 lines of code) and evaluate how they are doing.

The post What Makes a Good Test Suite? first appeared on Software Testing Magazine.

The Limits of Code Coverage

Software Testing Magazine — Mon, 10 Nov 2014 16:13:12 +0000

Code coverage is a metric that gives the degree to which the source code of a program is tested by a particular test suite. This metric is provided by open source or commercial code coverage tools and displayed in quality dashboards like SonarQube. There are many discussions about the right level of code coverage. In his book Quality Code, Stephen Vance explains the limit of this metric. Additionally, code coverage can deceive. Coverage only shows you the code that you executed, not the code you verified. The usefulness of coverage is only as good as the tests that drive it. Even well-intentioned developers can become complacent in the face of a coverage report. Here are some anecdotes of innocent mistakes from teams I have lead in the past that let you begin to imagine the abuse that can be intentionally wrought. A developer wrote the setup and execution phases of a test, then got distracted before going home for the weekend. Losing his context, he ran his build Monday morning and committed the code after verifying that he had achieved full coverage. Later inspection of the code revealed that he had committed tests that fully exercised the code under test but contained no assertions. The test achieved code coverage and passed, but the code contained bugs. A developer wrote a web controller that acted as the switchyard between pages in the application. Not knowing the destination page for a particular condition, this developer used the empty string as a placeholder [...]

The post The Limits of Code Coverage first appeared on Software Testing Magazine.