Mock Hell PyCon DE and PyData Berlin 2019

Mock Hell
PyConDE and PyData Berlin, 2019
edwin.jung@outlook.com
https://www.linkedin.com/in/junged/
twitter: @ejjcatx

•Backend Engineer
@ Quid
•Python => 1st
dynamic language
twitter: @ejjcatx

Perfect isolation,
100% coverage
Tests that test
nothing
Reverse-
engineering
mocks with the
debugger
Mocks that
prevent
refactoring
Lust
Gluttony
Greed
Fraud
Treachery
Heresy
Confusing patch
targets
Brittle assertions
Complex Setup
Deep/recursive
mocks; mocks-in-
mocks
Too many mocks
or patches
Limbo

# core.py
from db import db_read
def total_value(email, invoice_id, discount=0.0):
items = db_read(email, inv_no=invoice_id)
return sum(items)*(1.0-discount)

# test_core.py
from core import total_value
def test_total_value():
assert 300. == total_value(“karl@python.de”, 92)
# core.py

# test_core.py
from unittest.mock import patch, call
with patch('core.db_read') as mock_read:
# core.py

# test_core.py
with patch('core.db_read') as mock_read:
mock_read.return_value = [100, 200]
# core.py

# test_core.py
with patch(‘core.db_read’) as mock_read:
assert [call(“karl@python.de", inv_no=92)] == mock_read.calls
# core.py

News
Scraper
Internet S3
You have a large corpus of scraped
public news articles stored in S3, for
use in NLP experiments.

Market Movers
Data as of Jul 19
Friday’s Close:
Dow-68.77
27,154.20 -0.25%Nasdaq-60.754
2,976.61 -0.62%
S&P 500 | S&P 1500
Most Actives
Company Price Change % Change
MSFT Microsoft Corp 136.62 +0.20 +0.15%
BAC Bank of America Corp 29.40 -0.08-0.27%
…
MU Micron Technology Inc 45.52 +0.85
+1.90%
F Ford Motor Co 10.20 -0.06-0.58%
GE General Electric Co 10.04 -0.02-0.20%
T AT&T Inc 32.79 -0.30-0.91%
…
FCX Freeport-McMoRan Inc 11.49 +0.34
+3.05%
INTC Intel Corp 50.27 +0.33 +0.66%
PFE Pﬁzer Inc 42.77 -0.29-0.67%
>50% lines stock symbols

Write a script that scans your news archive
to check for stock quotes articles.

s3://my_bucket/news/2.txt
S3 Vocabulary
Key
Preﬁx
Bucket

S3
• To scan everything in a bucket:
• Get a paginated list of keys
• Download each object by key

{
"Name": “my_bucket”,
"Prefix": "news",
"MaxKeys": 1000,
"Contents": [
{
"Key": "news/",
"LastModified": "2019-07-21",
"Size": 0
},
{
"Key": "news/1.txt",
"Size": 12695
},
...
{
"Key": "news/3.txt",
"Size": 1587
}
],
...
}

├── newscheck
│   ├── __init__.py
│   ├── conﬁg.py
│   ├── stock.py
│   ├── core.py
│   ├── util.py
│   └── test_core.py
├── script.py

# script.py
from newscheck.core import find_bad_articles
if __name__ == "__main__":
print(list(find_bad_articles(“my_bucket”)))

# core.py
import boto3
import newscheck.config as config
import newscheck.stock as stock
from newscheck.util import *
def find_bad_articles(bucket_name):
client = boto3.client('s3', region_name=config.REGION_NAME)
for page in get_pages(client, bucket_name=bucket_name, prefix=config.PREFIX):
for key in keys_from(page):
lines = get_file(client, bucket_name, key)
if check_article(lines, config.THRESHOLD, stock.TICKER_SYMBOLS):
yield key

# util.py
+---- 4 lines: def get_pages(client, bucket_name, prefix): ---
+---- 6 lines: def keys_from(page):
+---- 7 lines: def get_file(client, bucket_name, key): ---
+--- 10 lines: def check_article(lines, threshold, stock_symbols): ---

# util.py
def get_pages(client, bucket_name, prefix):
paginator = client.get_paginator('list_objects')
page_iterator = paginator.paginate(Bucket=bucket_name, Prefix=prefix)
return page_iterator

# util.py
def keys_from(page):
for item in page['Contents']:
key = item['Key']
if key == f"{config.PREFIX}/": #ignore root
continue
yield key
+--- 10 lines: def check_article(lines, threshold, stock_symbols): —

# util.py
+---- 6 lines: def keys_from(page): ---
def get_file(client, bucket_name, key):
buf = io.BytesIO()
client.download_fileobj(bucket_name, key, buf)
# Decode and drop empty lines
buf.seek(0)
lines = (line.decode().strip() for line in buf.readlines())
return list(filter(lambda x:x, lines))

# util.py
+---- 7 lines: def get_file(client, bucket_name, key): —
def check_article(lines, threshold, stock_symbols):
limit = threshold * len(lines)
while lines and limit:
line = lines.pop()
first_word = line.split()[0]
if first_word in stock_symbols:
limit -= 1
return limit <= 0

# test_core.py
from unittest.mock import MagicMock, call, patch
class TestBadArticleFinder(unittest.TestCase):
@patch("newscheck.core.get_file")
@patch("newscheck.core.get_pages")
@patch("newscheck.core.boto3.client")
def test_find_bad_articles(self, client_mock, get_pages_mock, get_file_mock):
# Test something here!

page_stub = [{
"Contents": [
{"Key": 'news/'},
{"Key": 'news/good.txt'},
{"Key": 'news/bad.txt'}]
}]
get_pages_mock.return_value = page_stub

page_stub = [{
"Contents": [
{"Key": 'news/'},
}]
file_stubs = [
"lorem ipsum dolorumn foo baz bar bizn hello world".split('n'),
"MSFT 99.32n BAC 22.3n F 33.2n".split('n'),
]
get_file_mock.side_effect = file_stubs

page_stub = [{
"Contents": [
{"Key": 'news/'},
}]
file_stubs = [
]
bad_articles = list(find_bad_articles("my_bucket"))
self.assertEqual(["news/bad.txt"], bad_articles)

page_stub = [{
"Contents": [
{"Key": 'news/'},
}]
file_stubs = [
]
self.assertEqual([
call(client_mock.return_value, "my_bucket", "news/good.txt"),
call(client_mock.return_value, "my_bucket", "news/bad.txt")
],
get_file_mock.mock_calls
)

import boto3
yield key
Changing Imports?

import boto3.client as s3client
client = s3client('s3', region_name=config.REGION_NAME)
yield key
Changing Imports?

page_stub = [{
"Contents": [
{"Key": 'news/'},
}]
file_stubs = [
]
self.assertEqual([
],
)
Breaks this
patch

import boto3
client = boto3.client(‘s3', region_name=config.REGION_NAME)
yield key
Args to Kwargs?

import boto3
client = boto3.client(‘s3', region_name=config.REGION_NAME)
lines = get_file(client, bucket_name, key=key)
yield key
Args to Kwargs?

page_stub = [{
"Contents": [
{"Key": 'news/'},
}]
file_stubs = [
]
self.assertEqual([
],
)
Breaks these
assertions

page_stub = [{
"Contents": [
{"Key": 'news/'},
}]
file_stubs = [
]
self.assertEqual([
],
)
Missing an
assertion

page_stub = [{
"Contents": [
{"Key": 'news/'},
}]
file_stubs = [
]
self.assertEqual([
],
)
What if you want to
support tarballs
instead of S3?

page_stub = [{
"Contents": [
{"Key": 'news/'},
}]
file_stubs = [
]
self.assertEqual([
],
)
What if you
want different
checking logic?

Mocking is for:
•test isolation
•simulating dependencies
•avoiding side-effects
What went wrong?

Mocking is for:
•test isolation
•simulating dependencies
•avoiding side-effects
(Be careful about overmocking!)
What went wrong?

Mock Objects is an
extension to Test
Driven Development
that supports good
Object-Oriented
design …

It[’s] less interesting as
a technique for isolating
tests … than is widely
thought.

What went wrong.
Mocking is supposed to be a technique for (1) Object
Oriented Design, in the context of (2) TDD, for
exploratory design and discovery.
Mocking is not just a tool for test isolation.

“[Dependency Injection]
… is a virtue.”

Freeman and Pryce advocate what
many call “the London school of TDD,
…”
I’m not fully disagreeing … but for
maintainability … tests using mocks
creates more trouble than it’s
worth.

“Mocks aren’t Stubs”
A mock is a kind of test double. Other kinds of
test doubles include stubs, fakes, spies,
dummies.

“Mocks aren’t Stubs”
A mock is a kind of test double. Other kinds of
test doubles include stubs, fakes, spies,
dummies.
The difference between different “schools” of TDD,
is how you use test doubles.

from my_module import total_value
with patch('my_module.db_read') as mock_read:
assert [call(“karl@python.de”, inv_no=92)] == mock_read.calls
Option: Patch a Mock

stub returns
canned
values

mock validates
interaction
stub returns
canned
values

Option: Inject a Mock
# core.py

# core.py
def total_value(read, email, invoice_id, discount=0.0):
items = read(email, inv_no=invoice_id)

assert 300 == total_value(???, “karl@python.de”, 92)

mock_read = MagicMock()

assert 300 == total_value(mock_read, “karl@python.de”, 92)

Option: Inject a Fake

def fake_db_read(email, invoice_id):
with open(f’./fixtures/{email}/{invoice_id}.json’) as fobj:
return json.load(fobj)

assert 300 == total_value(fake_db_read, “karl@python.de”, 92)

assert 300 == total_value(fake_db_read, “karl@python.de”, 92)
assert 300. == total_value(mock_read, “karl@python.de”, 92)
Mockist
Classical

test
read
total
value
fake
read

Ports and Adapters
total
value
test
abs.
db_read
db
readapp
fake
Port
Adapter
Adapter

Hexagonal
total
value
test
abs.
db_read
db
readapp
fake

for page in get_pages(client, bucket_name, config.PREFIX):
if check_article(lines, config.THRESHOLD, config.STOCK_SYMBOLS):
yield key
if __name__ == "__main__":
print(list(find_bad_articles(“my_bucket”)))
To decouple check_article

Inject a Predicate
def find_bad_articles(bucket_name, predicate):
if predicate(lines):
yield key
if __name__ == "__main__":
print(list(find_bad_articles(“my_bucket”, predicate=???)))

Using a Closure
if __name__ == "__main__":
def is_stock_quotes(lines):
return check_article(lines,
config.THRESHOLD,
config.STOCK_SYMBOLS)
print(list(find_bad_articles(“my_bucket”, is_stock_quotes)))

“Dependency Injection is
just passing things in.”

What do you inject?
yield key

boto3?
def find_bad_articles(bucket_name, predicate, boto3):
yield key

client?
yield key

client?
def find_bad_articles(bucket_name, predicate, client):
yield key

get_pages, get_ﬁle…?
yield key

But what about keys_from?
yield key

Remember: Dependency Injection and
Mocking are Object Oriented Design

Single Responsibility
Open-Closed
Liskov Substitution
Interface Segregration
Dependency Inversion

ﬁnd
bad
keys
from
get
pages
script
get
ﬁle
pred-
icate

The Archive Source
keys
from
get
pages
script
get
ﬁle
ﬁnd
bad
pred-
icate

ﬁnd
bad
keys
from
get
pages
script
get
ﬁle
Archive
S3
Archive
pred-
icate

ﬁnd
bad
keys
from
get
pages
script
get
ﬁle
Archive
S3
Archive
“Object”
“Role”
“Mock Roles,
Not Objects”pred-
icate

ﬁnd
bad
keys
from
get
pages
script
get
ﬁle
Archive
S3
Archive
“Detail depends on Abstraction”
Dependency
Inversion
depends on
pred-
icate

Extract
yield key

def find_bad_articles(archive, predicate):
for page in archive.get_pages():
for key in archive.keys_from(page):
lines = archive.get_file(key)
yield key
Extract

Encapsulate
class S3Archive(object):
def __init__(self, bucket_name, prefix, region_name):
"""Ctor"""
self.client = boto3.client('s3', region_name=region_name)
self.bucket_name = bucket_name
self.prefix = prefix
+---- 7 lines: def get_file(self, key): --------------------------
+---- 4 lines: def get_pages(self): ------------------------------
+---- 6 lines: def keys_from(self, page): ------------------------

Inject in App
if __name__ == "__main__":
return check_article(lines, config.THRESHOLD, config.STOCK_SYMBOLS)
print(list(find_bad_articles(???, is_stock_quotes)))

Inject in App
if __name__ == "__main__":
return check_article(lines, config.THRESHOLD, config.STOCK_SYMBOLS)
archive = S3Archive(“my_bucket”, config.PREFIX, config.REGION_NAME)
print(list(find_bad_articles(archive, is_stock_quotes)))

for page in archive.get_pages():
for key in archive.keys_from(page):
yield key
Who should be responsible for
Paging and Key Parsing?

for key in archive.get_keys():
yield key
Delegate Responsibility to
Archive

def __init__(self, bucket_name, prefix, region_name):
"""Ctor"""
def get_keys(self):
"""Get an iterable of keys"""
for page in self.get_pages():
for key in self.keys_from(page):
yield key
Delegate Responsibility to
Archive

yield key

yield key
KafkaArchive?

Kafka
Stream of Tuples
“news/2.txt”, “lorem ispum dolorumn …”
“news/1.txt”, “quot et foo bar det in n …”
“news/3.txt”, “foos pis o lot forum box n …”
“news/9.txt”, “MSFT 99.34 n F 33.34 …”

yield key
KafkaArchive leads
to Liskov Violation

def __init__(self, bucket_name, prefix, client):
"""Ctor"""
def items(self):
for key in self.get_keys():
lines = self.get_file(key)
yield key, lines
def get_keys(self):
"""Get an iterable of keys"""
for page in self.get_pages():
for key in self.keys_from(page):
yield key
Hide Responsibility in Archive

for key, lines in archive.items():
yield key
Archive as a Tuple Stream

import unittest
def test_find_bad_articles(self):
data = {
"good.txt": ["lorem ipsum dolorum"],
"bad.txt": ["i am the bad article"]
}
def check(lines):
return lines[0] == "i am the bad article"
bad_articles = list(find_bad_articles(data.items(), check))
self.assertEqual(1, len(bad_articles))
self.assertEqual("bad.txt", bad_articles[0])
Test

twitter: @ejjcatx
Mocks aren’t Stubs (Fowler)
Clean Code (Bob Martin)
Growing Object-Oriented
Software, Guided by Tests
(Pryce, Freeman)
The Art of Unit Testing
(Osherove)

Mock Hell PyCon DE and PyData Berlin 2019

Recommended

More Related Content

What's hot (19)

Similar to Mock Hell PyCon DE and PyData Berlin 2019 (20)

Recently uploaded (20)

Mock Hell PyCon DE and PyData Berlin 2019