Test Driven Development in Python and BDD Testing

Overview of Test Driven Development (TDD) 

A key practice for extreme programming; it suggests that the code is developed or changed exclusively by the unit testing. Click to explore about, Test Driven Development (TDD) Tools

What is Test Driven Development (TDD)?

Test Driven Development (TDD) Approach

• Write a failing unit test
• Make the unit test pass
• Repeat

What is the Test Driven Development Process Cycle?

• First, add tests for the functionality.
• Next, we run our test to fail.
• Next, we write code according to the error we received.
• Then we run the tests again to see if the test fails or passes.
• Then refactor the code and follow the process again.

What are the benefits of Test Driven Development (TDD)?

• In TDD we build test before adding any new feature to it, that means in TDD approach our entire code is covered under the test. That’s a great benefit of TDD as compared to the code which has no test coverage.
• In TDD one should have a specific target before adding new functionality. This means before adding any new functionality one should be clear about its outcome.
• In an application, one method depends on the other. When we write tests before the method that means we should have clear thoughts about the interfaces between the methods. That allows us to integrate our method with the entire application efficiently and help in making our application modular too.
• As the entire code is covered by the test that means our final application will be less buggy. This is a big advantage of the TDD approach.

Test Driven Development increase the productivity and overall development of software/program. Click to explore about, Test Driven Development for Java using JUnit

What is Acceptance Test Driven Development (ATDD)?

What is Behavior Driven Development (BDD)?

What are the features of Behavior Driven Development (BDD)?

• The major change is in the thought process which is to be shifted from analyzing in tests to analyzing in behaviour.
• Ubiquitous language is used; hence it is easy to be explained.
• BDD approach is driven by business value.
• It can be seen as an extension to TDD; it uses natural language which is easy to understand by non-technical stakeholders also.

Database testing can be performed in a web application or desktop because the database can be used in the application. Click to explore about, Database Unit Testing

What are the approaches for Behavior Driven Development (BDD)?

We believe that the role of testing and test automation TDD(Test Driven Development) is essential to the success of any BDD initiative. Testers have to write tests that validate the behaviour of the product or system being generated. The test results formed are more readable by the non-technical user as well. For Behavior Driven Development to be successful, it becomes crucial to classify and verify only those behaviours that give directly to business outcomes. Developer in the BDD environment has to identify what program to test and what not to test and to understand why the test failed. Much like Test Driven Development, BDD also recommends that tests should be written first and should describe the functionalities of the product that can be suited to the requirements.

Behavior Driven Development helps greatly when building detailed automated unit tests because it focuses on testing behaviour instead of testing implementation. The developer thus has to focus on writing test cases keeping the synopsis rather than code implementation in mind. By doing this, even when the requirements change, the developer does not have to change the test, input and output to support it. That makes unit testing automation much faster and more reliable. Though BDD has its own sets of advantages, it can sometimes fall prey to reductions.

Development teams and Tester, therefore, need to accept that while failing a test is a guarantee that the product is not ready to be delivered to the client, passing a test also does not mean that the product is ready for launch. It will be closed when development, testing and business teams will give updates and progress report on time. Since the testing efforts are moved more towards automation and cover all business features and use cases, this framework ensures a high defect detection rate due to higher test coverage, faster changes, and timely releases.

What are the benefits of Behavior Driven Development (BDD)?

It is highly suggested for teams and developers to adopt BDD because of several reasons, some of them are listed below -

• BDD provides a very accurate guidance on how to be organizing communication between all the stakeholders of a project, may it be technical or non-technical.
• BDD enables early testing in the development process, early testing means lesser bugs later.
• By using a language that is understood by all, rather than a programming language, a better visibility of the project is achieved.
• The developers feel more confident about their code and that it won’t break which ensures better predictability.

A process that enables the developers to write code and estimate the intended behavior of the application. Click to explore about, Unit Testing of ML with Test Driven

Test Driven Development (TDD) with Python

Python Unit Testing

Test Driven Development (TDD) in Python with Examples

Setting Up Environment For Test Driven Development (TDD)

This is our directory structure

Writing Test For Test Driven Development (TDD)

import unittest
class Tdd_Python(unittest.TestCase):
 def test_banking_credit_method_returns_correct_result(self):
 bank = Banking()
final_bal = bank.credit(1000)
self.assertEqual(1000, final_bal)

File "/PycharmProjects/TDD_Python/test/tdd_example.py", line 6, in test_banking_credit_method_returns_correct_result
bank = Banking()
NameError: name 'Banking'
is not defined

How to implement Test Driven Development (TDD) in Python?

class Banking():

 def __init__(self):
 self.balance = 0

def credit(self, amount):
 pass

import unittest
from app.banking_app
import Banking

class Tdd_Python(unittest.TestCase):
 def test_banking_credit_method_returns_correct_result(self):
 bank = Banking()
final_bal = bank.credit(1000)
self.assertEqual(1000, final_bal)

if __name__ == '__main__':
 unittest.main()

AssertionError: 1000 != None
Ran 1 test in 0.002 s
FAILED(failures = 1)

class Banking():
 def __init__(self):
 self.balance = 0

def credit(self, amount):
 self.balance += amount
return self.balance

Testing started at 5: 10 PM...
Ran 1 test in 0.001 s
OK

import unittest
from app.banking_app
import Banking

class Tdd_Python(unittest.TestCase):
 def setUp(self):
 self.bank = Banking()

def test_banking_credit_method_returns_correct_result(self):
 final_bal = self.bank.credit(1000)
self.assertEqual(1000, final_bal)

def test_banking_credit_method_returns_error_if_args_not_numbers(self):
 self.assertRaises(ValueError, self.bank.credit, 'two')

if __name__ == '__main__':
 unittest.main()
 

Ran 2 tests in 0.002 s
FAILED(errors = 1)

class Banking():
 def __init__(self):
 self.balance = 0

def credit(self, amount):
 amount_type = (int, float, complex)

if isinstance(amount, amount_type):
 self.balance += amount
return self.balance
else :
 raise ValueError

Testing started at 5: 33 PM...
Launching unittests with arguments python - m unittesttdd_example.py in /PycharmProjects/TDD_Python / test
Ran 2 tests in 0.002 s
OK

import unittest
from app.banking_app
import Banking

class Tdd_Python(unittest.TestCase):
 def setUp(self):
 self.bank = Banking()

def test_banking_credit_method_returns_correct_result(self):
 final_bal = self.bank.credit(1000)
self.assertEqual(1000, final_bal)

def test_banking_credit_method_returns_error_if_args_not_numbers(self):
 self.assertRaises(ValueError, self.bank.credit, 'two')

def test_banking_debit_method_returns_correct_result(self):
 final_bal = self.bank.debit(700)
self.assertEqual(1000, final_bal)

def test_banking_debit_method_returns_error_if_args_not_numbers(self):
 self.assertRaises(ValueError, self.bank.debit, 'two')

if __name__ == '__main__':
 unittest.main()

AttributeError: 'Banking'
object has no attribute 'debit'
Ran 4 tests in 0.003 s
FAILED(errors = 2)

class Banking():
 def __init__(self):
 self.balance = 1000

def credit(self, amount):
 amount_type = (int, float, complex)

if isinstance(amount, amount_type):
 self.balance += amount
return self.balance
else :
 raise ValueError

def debit(self, amount):
 amount_type = (int, float, complex)

if isinstance(amount, amount_type):
 self.balance -= amount
return self.balance
else :
 raise ValueError
 

Testing started at 5: 44 PM...
Launching unittests with arguments python - m unittest / PycharmProjects / TDD_Python / test / tdd_example.py / PycharmProjects / TDD_Python / test
Ran 4 tests in 0.002 s
OK

Test Driven Development (TDD) Tools For Python

The best Test Driven Development for Python tools are listed below:

• nosetest

(venv) xenon@dm08:~/PycharmProjects/TDD_Python$ nosetests test/tdd_example.py 
----------------------------------------------------------------------
Ran 4 tests in 0.001s
OK

• py.test

• unittest

if __name__ == '__main__':
 unittest.main()

• unittest.mock

import unittest
from unittest.mock
import patch
from app.banking_app
import Banking

class TestBanking(unittest.TestCase):
 @patch('app.banking_app.Banking.credit', return_value = 1700)
def test_credit(self, credit):
 self.assertEqual(credit(700), 1700)

(venv) xenon @dm08: ~/PycharmProjects/TDD_Python$
py.test test / mock.py === === === === === === === === = test session starts === === === === === === === === === === =
 platform linux--Python 3.4 .3, pytest - 3.2 .5, py - 1.5 .2, pluggy - 0.4 .0
rootdir: /home/xenon / PycharmProjects / TDD_Python, inifile:
 collected 1 item

test / mock.py.

=== === === === === === === === == 1 passed in 0.14 seconds === === === === === === === === ===

Managed services for Enterprises to facilitate Automated Security Alerts, Single Click Deployments and Monitoring Solutions. Click to Talk to our Product Design and User Experience Solutions

Summary

• Explore here about Test Driven Development with React JS
• Click to know about System Testing Types, Best Practices and Tools