28: യൂണിറ്റ് ടെസ്റ്റിംഗ് ആമുഖം

ഇതുവരെ, ഒരു ഫംഗ്ഷൻ ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് നോക്കാൻ, അത് റൺ ചെയ്ത് ഔട്ട്പുട്ട് സ്വയം കണ്ണ് കൊണ്ട് പരിശോധിച്ചു. ഒരു വലിയ പ്രോഗ്രാമിൽ ഇത് പ്രായോഗികമല്ല — ഓരോ ചെറിയ മാറ്റത്തിനും എല്ലാം വീണ്ടും മാനുവലായി പരിശോധിക്കേണ്ടി വരും. ഓട്ടോമേറ്റഡ് ടെസ്റ്റുകൾ ഇത് നമുക്ക് വേണ്ടി ചെയ്യുന്നു.

`assert`: ഒരു ലളിതമായ തുടക്കം

assert ഒരു കണ്ടീഷൻ ശരിയാണോ എന്ന് പരിശോധിക്കുന്നു. ശരിയാണെങ്കിൽ ഒന്നും സംഭവിക്കില്ല. തെറ്റാണെങ്കിൽ AssertionError ലഭിക്കും.

def add(a, b):
	return a + b

assert add(2, 3) == 5
print("Test passed!")

ഫംഗ്ഷൻ തെറ്റാണെങ്കിൽ എന്ത് സംഭവിക്കുമെന്ന് നോക്കൂ:

def add(a, b):
	return a - b   # ബഗ്! ഇത് കൂട്ടലിന് പകരം കുറയ്ക്കുന്നു

assert add(2, 3) == 5
print("Test passed!")

AssertionError ലഭിക്കും, print("Test passed!") ഒരിക്കലും പ്രവർത്തിക്കില്ല. ഇതാണ് ടെസ്റ്റിംഗിന്റെ അടിസ്ഥാന ആശയം: പ്രതീക്ഷിക്കുന്ന ഫലവും യഥാർത്ഥ ഫലവും തമ്മിൽ താരതമ്യം ചെയ്യുക.

`unittest` മൊഡ്യൂൾ

ഒറ്റപ്പെട്ട assert സ്റ്റേറ്റ്മെന്റുകൾക്ക് പകരം, പൈത്തൺ unittest എന്ന ബിൽറ്റ്-ഇൻ ടെസ്റ്റിംഗ് ഫ്രെയിംവർക്ക് നൽകുന്നു — ഇത് ടെസ്റ്റുകൾ ഓർഗനൈസ് ചെയ്യാനും, എത്ര പാസായി എത്ര പരാജയപ്പെട്ടു എന്ന് വ്യക്തമായി കാണിക്കാനും സഹായിക്കുന്നു.

import unittest

def add(a, b):
	return a + b

class TestAdd(unittest.TestCase):
	def test_add_positive_numbers(self):
		self.assertEqual(add(2, 3), 5)

	def test_add_negative_numbers(self):
		self.assertEqual(add(-1, -1), -2)

unittest.main(argv=["ignored"], exit=False)
  • ടെസ്റ്റുകൾ എഴുതുന്നത് unittest.TestCase-ൽ നിന്ന് ഇൻഹെറിറ്റ് ചെയ്ത ഒരു ക്ലാസിലാണ് (ക്ലാസുകൾ അടുത്ത അധ്യായത്തിൽ പഠിക്കും)
  • ഓരോ ടെസ്റ്റ് മെത്തേഡിന്റെയും പേര് test_ എന്ന് തുടങ്ങണം — അല്ലെങ്കിൽ unittest അത് ടെസ്റ്റ് ആയി തിരിച്ചറിയില്ല
  • self.assertEqual(a, b) ഉപയോഗിച്ചാണ് താരതമ്യം ചെയ്യുന്നത്

സാധാരണ Assert മെത്തേഡുകൾ

മെത്തേഡ്പരിശോധിക്കുന്നത്
assertEqual(a, b)a, b തുല്യമാണോ
assertNotEqual(a, b)a, b തുല്യമല്ലേ
assertTrue(x)x True ആണോ
assertFalse(x)x False ആണോ
assertRaises(Error, func)func ഒരു നിശ്ചിത Exception ഉയർത്തുന്നുണ്ടോ

ഒരു ടെസ്റ്റ് പരാജയപ്പെട്ടാൽ എങ്ങനെ കാണപ്പെടും

import unittest

def square(x):
	return x * x

class TestSquare(unittest.TestCase):
	def test_square_of_4(self):
		self.assertEqual(square(4), 16)

	def test_square_of_5(self):
		self.assertEqual(square(5), 20)   # ബോധപൂർവ്വം തെറ്റായ പ്രതീക്ഷിത മൂല്യം

unittest.main(argv=["ignored"], exit=False)

രണ്ടാമത്തെ ടെസ്റ്റ് പരാജയപ്പെടും (square(5) യഥാർത്ഥത്തിൽ 25 ആണ്, 20 അല്ല), ഔട്ട്പുട്ടിൽ ഏത് ടെസ്റ്റ് പരാജയപ്പെട്ടു, എന്ത് പ്രതീക്ഷിച്ചു, എന്ത് കിട്ടി എന്ന് കൃത്യമായി കാണിക്കും — ഇത് ഒരു സാധാരണ print()-നേക്കാൾ കൂടുതൽ വിവരം നൽകുന്നു.

എന്തുകൊണ്ട് ടെസ്റ്റുകൾ എഴുതണം?

  • കോഡ് മാറ്റുമ്പോൾ, പഴയത് ഇപ്പോഴും ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് ഓട്ടോമേറ്റഡ് ആയി പരിശോധിക്കാം (റിഗ്രഷൻ ഒഴിവാക്കാൻ)
  • ഒരു ഫംഗ്ഷൻ എന്താണ് ചെയ്യേണ്ടത് എന്ന് ടെസ്റ്റുകൾ തന്നെ ഡോക്യുമെന്റ് ചെയ്യുന്നു
  • കോഡ് പുനഃക്രമീകരിക്കാൻ (refactor) ധൈര്യം തരുന്നു — എന്തെങ്കിലും തകർന്നാൽ ടെസ്റ്റുകൾ ഉടനെ കാണിക്കും

സാധാരണ തുടക്കക്കാരുടെ തെറ്റുകൾ

  • ടെസ്റ്റ് മെത്തേഡിന്റെ പേര് test_ എന്ന് തുടങ്ങാൻ മറന്ന്, unittest അത് ഒരു ടെസ്റ്റ് ആയി തിരിച്ചറിയാതെ വരുന്നു
  • സാധാരണ കേസുകൾ മാത്രം ടെസ്റ്റ് ചെയ്ത്, എഡ്ജ് കേസുകൾ (ശൂന്യ ലിസ്റ്റ്, പൂജ്യം, നെഗറ്റീവ് സംഖ്യ) മറന്നു പോകുന്നു
  • ഒരു ടെസ്റ്റിൽ ഒന്നിലധികം, ബന്ധമില്ലാത്ത കാര്യങ്ങൾ ഒരുമിച്ച് പരിശോധിക്കുന്നു — ഒരു ടെസ്റ്റ് ഒരു കാര്യം മാത്രം പരിശോധിക്കട്ടെ

ഈ അധ്യായത്തിന്റെ സംഗ്രഹം

  • assert ഉപയോഗിച്ച് അടിസ്ഥാന ടെസ്റ്റിംഗ് ആശയം പഠിച്ചു
  • unittest.TestCase ഉപയോഗിച്ച് ടെസ്റ്റുകൾ ഓർഗനൈസ് ചെയ്തു
  • assertEqual, assertTrue തുടങ്ങിയ മെത്തേഡുകൾ ഉപയോഗിച്ചു
  • ഒരു ടെസ്റ്റ് പരാജയപ്പെടുമ്പോൾ ഔട്ട്പുട്ട് എങ്ങനെ കാണപ്പെടും എന്ന് നേരിട്ട് കണ്ടു
  • ടെസ്റ്റുകൾ എഴുതുന്നത് എന്തുകൊണ്ട് ഉപകാരപ്രദമാണ് എന്ന് മനസ്സിലാക്കി

വ്യായാമങ്ങൾ

  • രണ്ട് സംഖ്യകൾ ഗുണിക്കുന്ന ഒരു ഫംഗ്ഷൻ എഴുതി, അതിന് 2 ടെസ്റ്റ് കേസുകൾ (unittest ഉപയോഗിച്ച്) എഴുതുക
  • ഒരു സ്ട്രിംഗ് "Hello" ആണോ എന്ന് പരിശോധിക്കുന്ന ഒരു ടെസ്റ്റ്, assertEqual-ഉം assertNotEqual-ഉം ഉപയോഗിച്ച് എഴുതുക
  • ബോധപൂർവ്വം ഒരു ടെസ്റ്റ് പരാജയപ്പെടുത്തുന്ന കോഡ് എഴുതി, ഔട്ട്പുട്ടിൽ എന്ത് വിവരമാണ് കാണിക്കുന്നത് എന്ന് നിരീക്ഷിക്കുക

Quiz & Self Assessment

ചോദ്യം 1 / 4
assert 2 + 2 == 5 എന്ന് എഴുതിയാൽ എന്ത് സംഭവിക്കും?

അടുത്ത അധ്യായത്തിൽ, പൈത്തണിലെ ഏറ്റവും പ്രധാനപ്പെട്ട ആശയങ്ങളിലൊന്നായ ക്ലാസുകളും ഒബ്ജക്റ്റുകളും (Object-Oriented Programming) നിങ്ങൾ പഠിച്ചു തുടങ്ങും.