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
assert 2 + 2 == 5 എന്ന് എഴുതിയാൽ എന്ത് സംഭവിക്കും?അടുത്ത അധ്യായത്തിൽ, പൈത്തണിലെ ഏറ്റവും പ്രധാനപ്പെട്ട ആശയങ്ങളിലൊന്നായ ക്ലാസുകളും ഒബ്ജക്റ്റുകളും (Object-Oriented Programming) നിങ്ങൾ പഠിച്ചു തുടങ്ങും.