Ben Finney said:
By definition, "private" functions are not part of the publicly
documented behaviour of the unit. Any behaviour exhibited by some
private component is seen externally as a behaviour of some public
component.
You know the difference between theory and reality? In theory, there is
none... Sometimes it's useful to test internal components. Imagine this
class:
class ArmegeddonMachine:
def pushTheButton(self):
"Destroy a random city"
city = self._pickCity()
self._destroy(city)
def _pickCity():
cities = ['New York', 'Moscow', 'Tokyo', 'Beijing', 'Mumbai']
thePoorSchmucks = random.choice(cities)
return 'New York'
def _destroy(self, city):
missle = ICBM()
missle.aim(city)
missle.launch()
The only externally visible interface is pushTheButton(), yet you don't
really want to call that during testing. What you do want to do is test
that a random city really does get picked.
You can do one of two things at this point. You can say, "But, that's not
part of the externally visible interface" and refuse to test it, or you can
figure out a way to test it. Up to you.
Sorry for the long post in advance. I'm busy studying unit testing$B!"(Band
here is how I would go about testing the above code.
1) Make the code more testable through public (not private)
interfaces. ie, split out the functionality into more public, but
still properly encapsulated forms (modules/classes, etc). Don't need
to make everything public, just enough that it's testable without
digging into privates attributes, but still well-encapsulated.
2) Link the split-up logic together (eg, in class constructors). Use
public attributes for this. Or use private attributes, but make them
updatable through public methods.
3) In the unit tests update the object being tested, so it uses mock
objects instead of the ones it uses by default (aka dependency
injection).
4) Run the methods to be tested, and check that the mock objects were
updated correctly.
Here is an example (very rough, untested & incomplete):
# Updated armageddonmachine module:
class CityPicker:
def pick(self):
cities = ['New York', 'Moscow', 'Tokyo', 'Beijing', 'Mumbai']
thePoorSchmucks = random.choice(cities)
return 'New York' # Your bug is still here
class Destroyer:
def destroy(self, city):
missle = ICBM()
missle.aim(city)
missle.launch()
class ArmegeddonMachine:
def __init__(self):
self.city_picker = CityPicker()
self.destroyer = Destroyer()
def pushTheButton(self):
"Destroy a random city"
city = self.city_picker.pick()
self.destroyer.destroy(city)
# unit test module for armageddonmachine
# Only has tests for CityPicker and ArmageddonMachine
import armageddonmachine
# Unit test code for CityPicker
# -- Mock objects --
class MockRandom:
def __init__(self):
self.choose = None
def choice(self, list_):
assert self.choose is not None
return list_[self.choose]
class TestCityPicker:
def setup()
# Setup code run before each unit test in this class
self.city_picker = CityPicker()
self._bkp_random = armaggedonmachine.random
def teardown()
# Teardown code run after each unit test in this class
armaggedonmachine.random = self._bkp_random
def test_should_pick_random_cities_correctly(self):
armaggedonmachine.random = MockRandom()
armaggedonmachine.choose = 0
assert city_picker.pick() == 'New York'
armaggedonmachine.choose = 1
assert city_picker.pick() == 'Moscow' # This will catch your bug
armaggedonmachine.choose = 2
assert city_picker.pick() == 'Tokyo'
armaggedonmachine.choose = 3
assert city_picker.pick() == 'Beijing'
armaggedonmachine.choose = 4
assert city_picker.pick() == 'Mumbai'
# Unit test code for ArmageddonMachine
# -- Mock Classes --
class MockCityPicker:
def __init__(self):
self.city_to_pick = "Test City"
def pick(self):
return self.city_to_pick
class MockDestroyer:
def __init__(self):
self.destroyed_cities = set()
def destroy(self, city):
self.destroyed_cities.append(city)
# -- Unit Tests
class TestArmageddonMachine:
def setup(self):
# Setup code that runs before each unit test in this class
self.machine = ArmageddonMachine()
self._bkp_picker = self.machine.city_picker
self._bkp_destroyer = self.machine.destroyer
self.machine.city_picker = MockCityPicker()
self.machine.destroyer = MockCityDestroyer()
def test_should_destroy_a_city(self):
self.machine.pushTheButton()
assert self.machine.destroyer.destroyed_cities == "Test City"
