-
-
-
-
URL copied!
I had an opportunity recently to play with test cases and asked my colleague, “What do I need to test?”
He said, “Mate, this is a unit test, and you need to decide the test cases according to the request and response, which should cover all the scenarios.”
This presented a dilemma for me, so I decided to write this complete guide for test cases. Let’s begin with my first question.
What is a Test Case?
In their simplest form, test cases are the set of conditions under which a tester determines whether the software satisfies requirements and functions properly. In layman’s terms, these are predefined conditions to check that the output is correct.
What Do I Need to test?
There is usually a simple answer to this question, by using a coverage package that measures the code coverage that also works during test execution. You can learn more about this in its official documents. Unfortunately, this was not the case in my situation.
The second approach is fairly straightforward. Typically, test cases are written by the developer of the code – and if you are the developer of the code, you are well aware of the flow of the code. In this situation, you need to write your test cases around the request and expected response of the code.
For example, if you are writing test cases for the division of a number, you must think about the code's expected input and expected output.
Test-driven Development Definition: "Test-driven development (TDD) is a software development process relying on software requirements being converted to test cases before software is fully developed, and tracking all software development by repeatedly testing the software against all test cases."
Django’s unit tests use a Python standard library module called unit test. The below module shows tests using a class-based approach.
How to Start Writing Test Cases
Here, we have one example for the method and class where we can start the test cases.
Class ProfileTestCase(TestCase):
def setUp(self):
pass
def test_my_test_1(self):
self.assertTrue(False)
def test_my_test_2(self):
self.assertTrue(False)
def tearDown(self):
pass
The following is a general test template for writing test cases in Django python.
For this example, TestCase is one of the most important classes provided by the unit test module, and it provides the foundation for testing our functions.
Also, for this example, SetUp is the first method that we run in our testing of the code. Therefore, it helps us set up the standard code required for each method that we can use in our entire testing process inside our testing class.
A teardown test case always runs last, as it can delete all objects or tables made while testing. It will also clean the testing environment after completing a test.
Now, let’s write out the test case:
Class CourierServices(TestCase):
def setup(self):
self.courier_data = CourrierModel.objects.all()
self.url = ‘/courier/service/’ #This is the url which we are going to hit for the response
def test_route(self):
response = self.client.get(self.url)
self.assertEqual(response.status_code,200) #here we are checking for the status 200
def test_zipcode(self):
test_courrier_zip_code(self):
zip_code = “110001”
query_param = {‘zip_code’: zip_code}
response = self.client.get(self.url, data=query_params) #(we are trying to hit the url(self.url) using #parameter(data=query_params) and collecting the response in (response))
self.assertEqual(200, response.status_code)
#here test the response code you get from the url and compare it with the 200
response_json = response.json()
results = response_json.get('results', [])
self.assertIsInstance(results, list)
self.assertEqual(results[0]['zip_code'], zip_code)
Here is another valuable code sequence, and here we are trying to test the most common code known as the Login Function:
Class loginTest(TestCase):
def setUp(self):
self.user = get_username_model().objects.create_user(username='test', password='test123', email='test@test.com',mobile_no=1234567890)
self.user.save()
def test_correct_user_pass(self):
user = authenticate(username='test', password='test123')
self.assertTrue((user is not None) and user.is_authenticated)
def test_wrong_username(self):
user = authenticate(username='fakeuser', password='test123')
self.assertFalse(user is not None and user.is_authenticated)
def test_wrong_password(self):
user = authenticate(username='test', password='fakepassword')
self.assertFalse(user is not None and user.is_authenticated)
def tearDown(self):
self.user.delete()
Note: A test method passes only if every assertion in the method passes. Now, you may be wondering, What do these assertions mean, and how do you know which ones are available? I will try to answer these questions as thoroughly as possible.
Here are some commonly used assertion methods:
Method | Meaning |
assertEqual(a, b) | a==b |
assertNotEqual(a, b) | a != b |
assertTrue(x) | bool(x) is True |
assertFalse(x) | bool(x) is False |
assertIs(a, b) | a is b |
assertIsNot(a, b) | a is not b |
assertIsNone(x) | x is None |
assertIsNotNone(x) | x is not None |
assertIn(a, b) | a in b |
assertNotIn(a, b) | a not in b |
assertIsInstance(a, b) | isinstance(a, b) |
assertNotIsInstance(a, b) | not isinstance(a, b) |
These methods are empowering; sometimes when we use them, an exact match isn’t required.
For example, how do I test for x-y = almost zero? This is where assertion methods can help. I see it as the “lifesaver” method.
Method | Meaning |
assertAlmostEqual(a, b) | round(a-b,7)==0 |
assertNotAlmostEqual(a,b) | round(a-b,7)!=0 |
assertGreater(a, b) | a>b |
assertGreaterEqual(a,b) | a>=b |
assertLess(a, b) | a<b |
assertLessEqual(a, b) | a<=b |
assertRegex(s, r) | r.search(s) |
assertNotRegex(s, r) | not r.search(s) |
assertCountEqual(a, b) | a and b have the same elements in the same number, regardless of their order. |
assertListEqual(a, b) | It compare two list |
assertTupleEqual(a, b) | It compare two tuple |
assertSetEqual(a, b) | It compare two set |
assertDictEqual(a, b) | It compare two dictionary |
Now that we know how to write the test cases, let me show you how to run them. Running the test cases is easy in Django python.
Write your test cases in the module, then go to the terminal and Run this command:
Python –m unittest my_test_module_1 my_test_module_2
If you want to run the test class, then use:
Python –m unittest my_test_module_1.TestClass
If you want to test your method, run this:
Python –m unittest my_test_module_1.TestClass.my_test_method
You can also run this test case:
Python -m unittest tests/my_test_testcase.py
Sometimes, we want to run the test cases via docker. For that, you can use the following method.
- First, go inside your web container using exec:
docker exec -it my-own-services_web_1 \bin\bash
- Then you will get the cmd prompt like this:
runuser@123456789:/opt/project123$
Note: You need to check your docker-compose.yaml and see the volume path. It will look something like this - .:/opt/app and it may change in your case.
python3 manage.py test test_folder.sub_folder.test_views.YourTestCases --settings=docker.test_settings
I hope this blog inspires you to start coding with the TDD approach, which will help make your code bug-free and robust too.
Remember the Golden Rules of TDD
- Write production code only to pass a failing unit test.
- Write no more of a unit test than is sufficient to fail (compilation failures are failures).
- Write no more production code than is necessary to pass the one failing unit test.
Next blog will cover the same in detail…
Top Insights
Manchester City Scores Big with GlobalLogic
AI and MLBig Data & AnalyticsCloudDigital TransformationExperience DesignMobilitySecurityMediaTwitter users urged to trigger SARs against energy...
Big Data & AnalyticsDigital TransformationInnovationRetail After COVID-19: How Innovation is Powering the...
Digital TransformationInsightsConsumer and RetailTop Authors
Top Insights Categories
Let’s Work Together
Related Content
Unlock the Power of the Intelligent Healthcare Ecosystem
Welcome to the future of healthcare The healthcare industry is on the cusp of a revolutionary transformation. As we move beyond digital connectivity and data integration, the next decade will be defined by the emergence of the Intelligent Healthcare Ecosystem. This is more than a technological shift—it's a fundamental change in how we deliver, experience, … Continue reading A Kickstarter for the Test-driven Development Python Django Approach →
Learn More
GlobalLogic wins at the 2023 Analytics Institute Awards, Dublin
*This blog was updated on Friday 16th June. The team is excited to announce that GlobalLogic was named winners of the Emerging Technology Award at last night's Analytics Institute Awards! This prestigious award recognises organisations that have successfully employed new technologies such as IoT, Edge Computing, Machine Learning, or RPA. Our submission showcased the successful application of … Continue reading A Kickstarter for the Test-driven Development Python Django Approach →
Learn More
MLOps Principles Part Two: Model Bias and Fairness
Welcome back to the second instalment of our two-part series – MLOps (Machine Learning Operations) Principles. If you missed part one, which focused on the importance of model monitoring, it can be found here. This blog explores the various forms that model bias can take, whilst delving into the challenges of detecting and mitigating bias, … Continue reading A Kickstarter for the Test-driven Development Python Django Approach →
Learn More
The GlobalLogic Academy Programme – a personal, introspective recollection
Ben Graham – Academy 2022 Graduate/Delivery Consultant I am currently in the DevOps capability for consulting and a recent graduate of the Academy 2022 programme which ran from September to December. I’d like to detail my thoughts on the process and share how my fellow graduates and I felt going on this journey. The GlobalLogic … Continue reading A Kickstarter for the Test-driven Development Python Django Approach →
Learn More
Seven steps to break down systemic gender barriers
Despite progress over the years, women are still significantly underrepresented in tech. Systemic gender barriers – such as unconscious bias, lack of access to education, and cultural norms – can make it difficult for women to break into the tech industry. But how do we break down these barriers? Follow our simple step by step … Continue reading A Kickstarter for the Test-driven Development Python Django Approach →
Learn More
MLOps Principles Part One: Model Monitoring
Machine learning (ML) has quickly become one of the most transformative technologies of our time – with applications in a wide range of industries, from healthcare and finance to retail and transportation. As organisations begin to adopt ML, they are facing new challenges arising from working with ML systems. Building, deploying and maintaining ML models … Continue reading A Kickstarter for the Test-driven Development Python Django Approach →
Learn More
Share this page:
-
-
-
-
URL copied!