Mocking in Python

name: inverse
layout: true
class: center, middle, inverse
---
# Mocking in Python
saurabh-kumar.com/mocking

---
layout: false
class: middle
.pull-left[
![](img/test-your-code.jpg)
]
.pull-right[
## Testing
- Prevent bugs
- Prevent regressions
- If not crucial, it's important
]
???
- this talk going to include a lot of tests
- If not crucial atleast important. 
- unit tests, integration tests, or any brand new test.
- defend us against bugs
- save us during regressions
- and save us from going to office on weekends.
---
class: center, middle, inverse
# Let's Begin, Part 1
???
- Let's begin with our journey
- understand few things about mock
- and how to use it
---
class: center, middle, inverse
# Mock simulates <br><br>.red[the looks and behaviour] of real objects.
???
- Mocking means creating objects 
- that simulates the looks and behaviour of real objects.
- in real world, test can include a lot of complexity
- and dependencies
- In order to isolate the object we can mock all the other real objects
---
class: center, middle
![](img/mock-eg1.png)
---
class: center, middle
.pull-left[
## Real
![](img/mock-eg2.2.png)
]
.pull-right[
## Mock
![](img/mock-eg2.1.png)
]
???
- lost a hell lot of gadgets
- 2nd, it can't cut, it's fake
- As with all the analogies, they are very easy to understand 
- but they are not 100% accurate.
---
class: center, middle, inverse
# Mocks != Stub
???
- might heard words like dummies, fakes, stubs
- They are somewhat similar in a way
---
class: middle
## Stubs
refers to writing classes or functions but not yet implementing them or have a predetermined behaviour.
```
class Foo(object):
  def bar(self):
    pass

def tank(self):
    return 'bla bla bla'
```
???
- stubs refers to writing classes or functions but not yet implementing them or have a predetermined behaviour.
- Stub is simple fake object. It just makes sure test runs smoothly.
- Mock is smarter stub. You verify Your test passes through it.
---
class: middle
.pull-left[
## Stubs
- Setup
- Test
- Verify State
- TearDown
]
.pull-right[
]
---
class: middle
.pull-left[
## Stubs
- Setup
- Test
- Verify State
- TearDown
]
.pull-right[
## Mocks
- Setup
- .red[Setup Expectations]
- Test
- .red[Verify Expectations]
- Verify State
- TearDown
]
---
class: middle
## unitest.mock    .grey[`# python 3.3`]
## mock        .grey[`# python 2.x`]
???
- Both the packages same on both the version
- Developed by Michal Foord, who was also at Python India 2014
---
class: center, middle, inverse
# Mock()
???
- mock has well documented 
- can fake any property or behaviour
---
class: middle
# Mock
```python
>>> from unittest.mock import Mock
>>> m = Mock()
>>> m.foo = 1
>>> m.foo
1
>>> m.bar
<Mock name='mock.bar' id='4593003768'>
```
---
class: center, middle, inverse
# Mock()
# MagicMock()
---
class: middle
## MagicMock
Similar to mock but has default implementation for magic methods:
<pre>
__lt__         __str__
__gt__         __init__
__len__        __hash__
__bool__       __exit__
...
</pre>

```python
>>> from unittest.mock import MagicMock
>>> m = MagicMock()
>>> len(m)  # or m.__len__()
0
```
---
class: center, middle, inverse
# Mock()
# MagicMock()
# patch()
---
class: middle
# Patching
```python
from unittest.mock import patch

with patch('pydelhi.conference.send_sms') as sms_sender_mock:
  sms_sender_mock.return_value = True
```
???
- path to module/object as string
---
class: middle
# Patching

## .red[`'pydelhi.conference.send_sms'`]
point to place with object was used rather than where it's defined

.pull-left[
```
## sms.py

def send_sms(phone, text):
   pass
```
]
.pull-right[
```
## pydelhi/conference.py

from sms import send_sms
send_sms('...', '...')
```
]
???
- key to patching is point to place with object was used rather than where it's defined
---
class: center, middle, inverse
# Mock the object .red[where it's used] <br><br>not .red[where it came from]
---
class: center, middle, inverse
# Let's Move on: Part 2
---
class: center, middle, inverse
# Useful Mocks
## Typical use-cases where mocks are useful
---
class: middle
# System calls
```python
with patch.dict('os.environ', {'ANDROID_ARGS': ''}):
  pf = Platform()
  self.AssertTrue(pf == 'Android')
```
.footnote[source: kivy]
---
class: middle
# Streams
```python
@mock.patch('sys.stdout', new_callable=six.StringIO)
def test_print_live_refs_empty(self, stdout):
  trackref.print_live_ref()
  self.assertEqual(stdout.getvalue(), 'Live References\n\n\n')
```
.footnote[source: Scrapy]

---
class: middle
# Networking
```python
@patch('django.utils.six.moves.urllib.request.urlopen')
def test_oembed_photo_request(self, urlopen):
  urlopen.return_value = self.dummy_response
  result = wagtail_oembed("http://www.youtube.com/watch/")
  self.assertEqual(result['type'], 'photo')
```
.footnote[source: Wagtail]
---
class: middle
## IO operations

```python
@patch.object(DataLoader, '_get_file_contents')
def test_parse_json_from_file(self, mock_def):
  mock_def.return_value = ({"a": 1, "b": 2}, True)
  output = self._loader.load_from_file('dummy_json.txt')
  self.assertEqual(output, dict(a=1, b=2))
```

.footnote[Source: Ansible]
---
class: middle
## Clocks, time, timezones
```
@mock.patch('time.sleep')
def test_500_retry(self, sleep_mock):
  self.set_http_response(status_code=500)

# Create a bucket, a key and a file
  with self.assertRaises(BotoServerError):
    k.send_file(fail_file)
```

.footnote[Source: Boto]
---
class: middle
## Unpredictable results
```
with mock.patch('random.random', return_value=0.0):
  with self.assertChanges(get_timeline_size, before=10, after=5):
    backend.add(timeline, next(self.records))

```

.footnote[Source: Sentry]
---
class: middle, center

### system calls
### streams
### Networking
### IO Operations
### Clocks, time, timezones
### Unpredictable results

---
class: middle
# Why we like them?
- Save time
- Make impossible possible
- Exclude external dependencies
---
class: middle, center, inverse
## Moving on: Part 3
# Bad Mocks
---
class: middle
# Problems?
```
with patch.object(Pony, 'save_base') as mock_save:
  form = PonyForm(instance=pony, data=data)
  self.assertTrue(form.is_valid())

save_pony = form.save()
  self.assertTrue(saved_pony.age, 3)
  mock_save.assert_called_once()
```
---
class: middle
# Problems?
```
with patch.object(Pony, 'save_base') as mock_save:
  form = PonyForm(instance=pony, data=data)
  self.assertTrue(form.is_valid())

save_pony = form.save()
  self.assertEqual(saved_pony.age, 3)
  mock_save.assert_called_once()
```
## .red[`self.assertEqual(saved_pony.age, 3)`]
---
class: middle
# Problems?
```
with patch.object(Pony, 'save_base') as mock_save:
  form = PonyForm(instance=pony, data=data)
  self.assertTrue(form.is_valid())

save_pony = form.save()
  self.assertEqual(saved_pony.age, 3)
  mock_save.make_me_sandwich()
```
## .red[`mock_save.make_me_sandwich()`]
---
class: middle
# Problems?
```
with patch.object(Pony, 'save_base') as mock_save:
  form = PonyForm(instance=pony, data=data)
  self.assertTrue(form.is_valid())

save_pony = form.save()
  self.assertEqual(saved_pony.age, 3)
  self.assertEqual(mock_save.call_count, 1)
```
### `self.assertEqual(mock_save.call_count, 1)`
???
Correct one, from the documentation.
---
class: middle, centre
![](img/arch.png)
---
class: middle, center, inverse
## Thank You
### Saurabh Kumar /  @_theskumar
[Questions?]