Posts

Q & A Best Practices

On top of delivering a project on time and within budget, developers must test for quality assurance upon completion to ensure stakeholders’ expectations have been met.

However, testing for quality after a product is built, usually results in far too little, too late. The agile model of software development encourages practicing quality assurance throughout every phase of the project. The agile way also prioritizes quality by making it the responsibility of every team member, not just the QA testers. As a result, the QA team coordinates efforts with the development team at each iteration, providing continuous testing.

Implementing a feedback loop is a fundamental step in the quality assurance process. In order to guarantee that the product meets all of the requirements (feature functionality, design, reliability, usability and efficiency), it can be helpful to enlist the perspectives of those with varying backgrounds. This can include those proficient in testing, business and or development.

Quality assurance testing can be both manual and automated. While both approaches are proficient at mitigating bugs, automated software testing is often more beneficial in that it is quicker and more effective at checking for code correctness. It’s important to remember that the goal of Q & A testing is to find faults within the software so that an error-free application can be delivered to the client.

The following are integral software testing methods when best practicing quality assurance:

Test Driven Development (TDD)

TDD works by building a project’s code around the QA tests. The programming team first designs and builds tests for functional code, and then creates code that will pass them. This development method helps everyone gain an understanding of the code’s purpose before development; guaranteeing the initial functionality of the code and effectively building in quality.

Behavior Driven Development (BDD)

Similar to TDD, in that the test is written before the code, BDD tests the behavior of an application under specific conditions. This is done with the end user in mind. As development progresses, BDD often proves to be more reliable than TDD. BDD is also written in English instead of code, allowing for a more streamlined feedback loop.

Acceptance Tests

Acceptance tests are simple pass or fail tests that check whether or not a feature behaves as it should. These are often automated to meet customer and business requirements.

Regression Tests

Once one feature is functional, regression tests ensure it’s stability throughout the software’s other modifications. As more features are built, these automated tests check that the others aren’t being negatively affected as a result.

Exploratory Tests

Exploratory tests are usually manual, in that a human operates the software looking for unknown unknowns. These tests are meant to identify new situations that the development or QA teams haven’t thought of.

Once a product thoroughly meet’s it’s intended purpose and performs well under pressure, the QA testing is complete.

At Number8, we believe in developing software that is user-friendly, reliable and completely functional. As a result, we are always recruiting talented QA professionals for quality assurance jobs on our team. To learn more about how we can help you complete and successfully launch your software project, contact us at 502-890-7665. 

Why Programmers Include Unit Tests for Quality Assurance

Described concisely and directly, Unit Tests is Quality Assurance (QA) for the core of your software. The main difference between Unit Tests and regular QA is that Unit Tests are not done by a user interacting with the software directly. In fact, they are done by a programmer with code.

When we develop software, it must meet an objective or main requirement.

  • The core of the software is the code that relates directly to that objective.
  • The core is essential. If it does not function correctly, the software has no purpose.

Examples of software cores:

  • Online Payment – the code that processes the credit card or web payment method given by the user.
  • Hotel Booking Engine – the code that associates the user’s information to the hotel room and saves this to a database.
  • Scientific Calculator – the code that performs the actual calculations and returns a result.

When a software is declared ‘done,’ Quality Assurance (QA) tests the software to assure it satisfies its objective.

  • In a controlled environment, QA tests every core function possibility, making sure nothing breaks and everything works as expected.
  • The core is outlined clearly with every one of its cases for QA to test continuously.

The number of tests QA needs to perform can grow rapidly…

For instance, take a basic calculator (a relatively simple, single page application) that uses 4 basic functions (ADD / SUBTRACT / MULTIPLY / DIVIDE)

At first, QA needs to test the calculator’s 4 basic functions…

However, to ensure quality, QA needs to test every possible combination of functions at one time. 

One feature at a time:
ADD SUBTRACT
MULTIPLY DIVIDE

 

Two features at a time:
ADD / SUBTRACT ADD / MULTIPLY ADD / DIVIDE
SUBTRACT / MULTIPLY SUBTRACT / DIVIDE MULTIPLY / DIVIDE

 

Three features at a time:
ADD / SUBTRACT / MULTIPLY ADD / MULTIPLY / DIVIDE
SUBTRACT / MULTIPLY / DIVIDE SUBTRACT / DIVIDE / ADD

 

Four features at a time:
ADD / SUBTRACT / MULTIPLY / DIVIDE

 

  • For a basic calculator application that has four functions, QA needs to run 15 tests continuously to ensure it works properly.
  • Each scenario should be tested with its own input and all outputs need to be verified.
  • Now imagine another a new function is added to the app, for example, the trigonometric function sine. You have to test all the above functions again, but this time with the sine code added.
  • With the addition of 1 function, the number of tests increases from 15 to 31. The addition of 1 function doubles the number of tests to perform and forces QA to repeat tests.
  • A typical scientific calculator includes at least 13 functions:  add, subtract, multiply, divide, percent, sine, cosine, tangent, square root, nth root, exponent, log, factorial.
  • That yields a grand total of 8191 different test cases to perform!

This amount of QA is not feasible for a person to perform…. enter unit tests.

  • Unit Tests are QA for the software core done by machine calculations, therefore free of human errors.
  • Unit Tests will send inputs to the software core and evaluate the result.
  • The fact that it is done by code helps test a big number of cases and vary the inputs accordingly.

Typical Unit Test Structure

Given… Inputs
It (when)… Code to be tested.
Should (then)… Evaluation of results.
  • In the ‘Given’ section the programmer declares the inputs that will be passed to the feature tested. This can be a single number (like the calculator) or a different input, like a database object.
  • In the ‘It’ section, the programmer details the function or code that will be run and tested.
  • In the ‘Should’ section the results are evaluated and the Unit Test passes or fails.
  • Unit Tests include objects called ‘Mocks’ which resemble a database record. The programmer hardcodes the Mock’s attributes values, but it is important to note that the attributes are the same as a database record attributes, making it able to be tested.

 

Unit Tests are not fancy, unnecessary code

  • Unit Tests run quickly while verifying outputs correctly.
  • They are scalable and fit for applications with multiple requirements.
  • When a new variable is added, tests that verified the old cases can be reused.
  • Unit Tests are not a luxury, but an advanced way of doing QA by code that is needed when the software that wants to be tested has too many cases for a human to consider.
  • Plus, they are free from a human error, like passing a wrong input or interpreting the result incorrectly.
  • Unit Tests make QA more efficient while making it harder for its members to enter, as they will require a programming background.

 

At Number8 our programmers implement necessary code to ensure your software products can handle all functions and develop as needed. If you are interested in learning more about our development process or if you think you are qualified to join our team, then give us a call at (502) 890-7665 today!