dkennedy.io

Yesterday's Web

2026-08-02T22:02:41Z

I was cleaning off my desk the other day and found a mysterious, unlabeled hard drive. Plugging it in and examining its contents turned into a trip down memory lane and a bit of an emotional roller coaster: pride at my early ideas and ambitions mixed with embarrassment at my lack of self-awareness.

You won't see any responsive design here -- it wasn't a thing until 2010 -- so these screenshots will look like garbage on a phone. For the optimal viewing experience, use one of these:

Xion Design

My brother and I named our first web design company after the fictional setting of The Matrix, except we spelled it with an X because it's cool:

The blurry hose spigot and random scribbles are my original photography, as are the sunflowers in this redesign:

At least the part about frisbee and pizza is true. Believe it or not, we had clients despite the cringe-inducing copy.

EndGame Clan

All the cool kids wanted to join my Natural Selection team. Did we usually win? Nope! But we had a sweet website and logo. Plus, every member got a custom nametag to use on the forums:

EndGame Creations

I wanted to be a level designer, so naturally I made a website:

The idea was to host all kinds of level-design-related stuff: textures, skies, maps, etc. But my contributors didn't contribute much, hence the desperate cry for content.

EndGame Network

Once I had three distinct but related websites, I had a network. Never mind its contituents were little more than hollow shells:

My big plans to take on GameSpy didn't get much farther than a landing page.

Innovative Renovation Services

This contractor was so impressed with the logo I designed that he hired me to create his website too:

I never cared for the logo. Or the website. But my client was thrilled, and that's what matters.

Egoflux

This is basically my space before MySpace, with just a hint of emo:

I don't know why I thought my inflated ego would comfort anyone, but Jimmy Buffet and Nine Inch Nails on the same playlist is sure to make their skin crawl.

Portfolio 2003

For my first portfolio, I opted for a gray box floating in an empty white void, with light text on a light background. Nothing says "experienced designer" quite like this:

At least I had the presence of mind to redesign it less than a year later:

This is a little better, but it would take years for me to learn how to use contrast.

Photography

When I got my hands on a Canon Rebel SLR with a macro lens, I went nuts. Here's a small selection from that period:

1031 Corporation

The first time I applied for a job at a real software shop, they gave me some text and images and asked me to come up with a proof of concept, which I turned around overnight:

They must have been impressed because they offered me the job, but I had to decline because the nine-to-five schedule conflicted with my studies. I was more interested in teaching than programming.

CK Hardwood Floors

I don't remember much about this client. I think they paid me for the design but then had to put it on hold. Too bad, it looks halfway decent:

Mike's Colorado Fishing

My dad was a regular contributor to several local fishing publications, amassing a large enough audience to warrant his own website. This might have been one of the last framesets on the internet:

I'm pretty sure his website received more traffic than all of mine combined. It definitely had more content.

Yonder DeZine/Swell Designs

My brother and I finally changed the name of our company around 2005:

It didn't last long. We changed it again around 2006. I love this logo, but the text could have used a little more polish:

I believe 1999 is a reference to the year I published my first page on GeoCities, which consisted entirely of animated Dragon Ball Z gifs.

TCBY at DIA

This was our biggest client ever, netting hundreds of dollars over the course of several months. No need for random assets here -- they gave us plenty of material to work with:

I'm still proud of this design. It's distinctive, fun, and on brand, right down to the color palette. Could have used more sprinkles though.

Portfolio 2006

This version of my portfolio featured glossy buttons, popup windows, and overlong explanations:

The Kennedy Family

Before Facebook, this seemed like the easiest way to share news and photos of my growing family:

Law Office of Aaron Fethke

This lawyer made the wise choice to go pro with an online business card designed by yours truly:

The copyright says 2010 because that's when I grabbed the screenshot. It was more like '07 or '08 when I made this.

Mica Photography

This photographer knew exactly what she wanted. She provided the design, colors, logo, and other assets, which made my job very easy:

Mr. Kennedy's Classroom

I made this one for my brother after he graduated:

This is one of my favorite projects ever. I love how it looks -- the classroom theme is so natural. I had lots of fun drawing the graphics by hand in Photoshop. And this is the first website I made using PHP and SQL, so I learned a ton.

Chris Steinbach Photography

This photographer's work speaks for itself:

I worked with Chris for years, redesigning his website several times. It was never quite minimalist enough for him.

Portfolio 2010

Thanks to The Non-Designer's Design Book by Robin Williams, I finally learned how to use contrast:

CMSnap

I developed this CMS while working with Chris Steinbach, allowing him to easily and frequently update his gallery. It wasn't pretty to look at, but it was easy to add and edit pages, upload images, and manage users:

Eventually I converted all my clients' websites to use CMSnap, for free, because it was fun.

Retriever Cinema

I got my foot in the door at software shop doing customer support and testing. This company specialized in POS software for movie theaters and restaurants. When they decided to add custom WordPress sites to their services, I made the demo page:

Michael's Denver

My friend operated this business for way too long without an online presence, so I offered to help. Unfortunately, this is another design that never made it past the idea stage:

Fun or Not Fun

This was my most ambitious project before landing my first job as a software developer:

It included the best parts of CMSnap and added better tools for managing image galleries and creating thumbnails:

I had a staff of unpaid writers. We were all hoping it would take off like Destructoid or GameTrailers, but it turns out that takes a lot more work than any of us had time for. Detecting a theme yet?

Remove Extra Fonts and Languages on Ubuntu

2023-06-15T15:43:40Z

I don't know about you, but I only speak, read and write fluently in my native language: English. So when I go hunting for a font I don't want to see this:

Or this:

According to the documentation, Noto provides "high-quality fonts for writing in all modern and ancient languages." So unless you're Tolkien you probably don't need it. And according to its package description:

The name "Noto" is short for "No Tofu"... Tofu (豆腐) is Japanese jargon for unicode replacement character "�" (U+FFFD)

Even after uninstalling it from my system, those Japanese characters appear to render correctly in the browser and in the terminal:

Now the Fonts app and font picker are more usable on my system.

I also removed a ton of extra language packages that were added to my system during its initial setup. Modify as desired if you speak the Queen's English or something else:

#!/usr/bin/env bash

aptitude purge --purge-unused \
    fonts-arphic-ukai \
    fonts-arphic-uming \
    fonts-noto-cjk \
    fonts-noto-cjk-extra \
    fonts-noto-core \
    fonts-noto-ui-core \
    gnome-user-docs-de \
    gnome-user-docs-es \
    gnome-user-docs-fr \
    gnome-user-docs-it \
    gnome-user-docs-ja \
    gnome-user-docs-pt \
    gnome-user-docs-ru \
    gnome-user-docs-zh-hans \
    hunspell-ar \
    hunspell-de-at-frami \
    hunspell-de-ch-frami \
    hunspell-de-de-frami \
    hunspell-en-au \
    hunspell-en-ca \
    hunspell-en-gb \
    hunspell-en-za \
    hunspell-es \
    hunspell-fr \
    hunspell-fr-classical \
    hunspell-it \
    hunspell-pt-br \
    hunspell-pt-pt \
    hunspell-ru \
    hyphen-de \
    hyphen-en-ca \
    hyphen-en-gb \
    hyphen-es \
    hyphen-fr \
    hyphen-it \
    hyphen-pt-br \
    hyphen-pt-pt \
    hyphen-ru \
    ibus-chewing \
    ibus-libpinyin \
    ibus-mozc \
    ibus-table-cangjie3 \
    ibus-table-cangjie5 \
    ibus-table-quick-classic \
    ibus-table-wubi \
    language-pack-ar \
    language-pack-ar-base \
    language-pack-de \
    language-pack-de-base \
    language-pack-es \
    language-pack-es-base \
    language-pack-fr \
    language-pack-fr-base \
    language-pack-gnome-ar \
    language-pack-gnome-ar-base \
    language-pack-gnome-de \
    language-pack-gnome-de-base \
    language-pack-gnome-es \
    language-pack-gnome-es-base \
    language-pack-gnome-fr \
    language-pack-gnome-fr-base \
    language-pack-gnome-it \
    language-pack-gnome-it-base \
    language-pack-gnome-ja \
    language-pack-gnome-ja-base \
    language-pack-gnome-pt \
    language-pack-gnome-pt-base \
    language-pack-gnome-ru \
    language-pack-gnome-ru-base \
    language-pack-gnome-zh-hans \
    language-pack-gnome-zh-hans-base \
    language-pack-gnome-zh-hant \
    language-pack-gnome-zh-hant-base \
    language-pack-it \
    language-pack-it-base \
    language-pack-ja \
    language-pack-ja-base \
    language-pack-pt \
    language-pack-pt-base \
    language-pack-ru \
    language-pack-ru-base \
    language-pack-zh-hans \
    language-pack-zh-hans-base \
    language-pack-zh-hant \
    language-pack-zh-hant-base \
    libchewing3 \
    libchewing3-data \
    libmarisa0 \
    libopencc-data \
    libopencc1.1 \
    libpinyin-data \
    libpinyin13 \
    libreoffice-help-de \
    libreoffice-help-en-gb \
    libreoffice-help-es \
    libreoffice-help-fr \
    libreoffice-help-it \
    libreoffice-help-ja \
    libreoffice-help-pt \
    libreoffice-help-pt-br \
    libreoffice-help-ru \
    libreoffice-help-zh-cn \
    libreoffice-help-zh-tw \
    libreoffice-l10n-ar \
    libreoffice-l10n-de \
    libreoffice-l10n-en-gb \
    libreoffice-l10n-en-za \
    libreoffice-l10n-es \
    libreoffice-l10n-fr \
    libreoffice-l10n-it \
    libreoffice-l10n-ja \
    libreoffice-l10n-pt \
    libreoffice-l10n-pt-br \
    libreoffice-l10n-ru \
    libreoffice-l10n-zh-cn \
    libreoffice-l10n-zh-tw \
    mozc-utils-gui \
    mythes-ar \
    mythes-de \
    mythes-de-ch \
    mythes-en-au \
    mythes-es \
    mythes-fr \
    mythes-it \
    mythes-pt-pt \
    mythes-ru \
    wbrazilian \
    wbritish \
    wfrench \
    witalian \
    wngerman \
    wogerman \
    wportuguese \
    wspanish \
    wswiss

Note the following packages were not included in the script above:

hunspell-en-us
hyphen-en-us
language-pack-en
language-pack-gnome-en
libreoffice-help-en-us
mythes-en-us
wamerican

Also note I'm running Pop!_OS, which might include different packages than Ubuntu.

Vim's Expression Register

2023-04-28T00:54:40Z

Say you'd like to insert the current date and time into the document you're editing. Obviously, you could do it by hand. But what if you need to do it a lot? And what if you need it to be ISO format? That's kind of tedious and error prone. Instead, you can enter the following command:

:put = strftime('%FT%T%z')

This syntax is misleading. It looks like we're assigning the result of a function call to a variable named put. Actually, we're calling the :put command with two arguments: the name of a register and an expression. Normally, :put x would insert the contents of register x on a new line after the cursor. :put = is an exception in that it allows a second argument: an expression to be evaluated before it's inserted. After running this command, the expression register will contain the expression, not the result. You can see this for yourself with :reg =, which displays:

Type Name Content
  c  "=   strftime('%FT%T%z')
Press ENTER or type command to continue

A nice side-effect of this is you can re-evaluate the expression and insert the new result with :put =, leaving out the second argument. You're already thinking of ways to exploit this, aren't you?

Anyways, I can never remember this command. I'd much rather create a user-defined function with a blatantly obvious name:

function! InsertDate()
    put = strftime('%FT%T%z')
endfunction

I can call this function with :call InsertDate(), but I prefer to make it even easier with a user-defined command:

command! InsertDate call InsertDate()

This way, I can just enter :InsertDate.

Now, say you'd like to insert the date and time on the current line after the cursor instead of on a new line. The :put command only works "linewise", meaning it can only insert text on a new line, and there's no alternative command that works like :put that is "charwise." You can use the normal mapping "xp to insert the contents of register x on the current line after the cursor, but "=p doesn't insert anything. Instead, it prompts you to enter an expression. So you type "=strftime('%FT%T%z') and hit the Enter key and -- what happened? Turns out this is just another way to set the contents of the expression register. To insert the result of the expression, use the normal mapping p to insert the contents of the unnamed register, which contains the result of the expression until you use it, at which point its contents are replaced by whatever was there before. If you want to insert the result of the expression again, you have to type "=, followed by the Enter key, followed by p. This crazy behavior is undocumented as far as I can tell.

Whatever. This is why we created a function, so we don't have to jump through all these inane hoops every time we want to insert the date and time:

function! InsertDate()
    normal "=strftime('%FT%T%z')^Mp
endfunction

This technically works but it contains a literal carriage return character. The ^M is a single character, not caret followed by M, which you can enter in insert mode with Ctrl-V followed by the Enter key. Control characters don't always play nice with other programs -- I had to use a caret followed by M to display it correctly in the browser. You can replace it with the string <CR>, which vim interprets as the Enter key. But the :normal command doesn't recognize special characters like <CR> or <Esc>, so we have to wrap the whole line in the :execute command:

function! InsertDate()
    execute "normal \"=strftime('%FT%T%z')\<CR>p"
endfunction

Make sure to escape the double quote in the middle of the command and the <CR>. Clear as mud, right?

I started translating this to Lua, hoping it would simplify things. While it's arguably easier to understand, it's also quite verbose:

function insert_date()
  local pos = vim.api.nvim_win_get_cursor(0)[2]
  local line = vim.api.nvim_get_current_line()
  local new_line = line:sub(0, pos) .. os.date('%FT%T%z') .. line:sub(pos + 1)
  vim.api.nvim_set_current_line(new_line)
end

What I really want is something like this:

function insert_date()
    vim.buffer.insert(os.date('%FT%T%z'))
end

I love the idea of an editor that's easy to program and customize, but it often requires a lot more effort than most users are willing to muster. When I'm writing and I need to insert the current date and time, I don't want to think about escape sequences, ex-commands, normal mode, special registers, etc. Whatever efficiency I gained from this exercise is eclipsed by the time I spent poring over documentation and help forums (not to mention writing this article). It might be worth the effort if I could apply what I learned here elsewhere, but I know I'm in for another learning curve the next time I'm tempted to extend my favorite editor.

Vim is so full of idiosyncrasies like this, I could turn this post into a series. Maybe I will. Then again, maybe I'm done with vim.

OpenWrt Wi-Fi Schedule

2023-03-07T02:58:05Z

If I let them, my kids will stay up all night watching YouTube or TikTok or whatever. We have a no-devices-in-room policy, but disabling the wi-fi gives me a little more peace of mind.

Of course, I don't want to disable the wi-fi to all the devices in the house at bedtime. So I wrote this script:

#!/usr/bin/env sh

if [ -z "$1" ]; then
    logger -st 'wifi-schedule' 'Missing argument'
    exit 1
fi

if [ "$1" != 'up' -a "$1" != 'down' ]; then
    logger -st 'wifi-schedule' "Invalid argument: $1"
    exit 1
fi

logger -st 'wifi-schedule' "Toggling wifi schedule $1"

add_mac() {
    if ! echo "$1" | grep -Eiq '^([a-f0-9]{2}:){5}[a-f0-9]{2}$'; then
        logger -st 'wifi-schedule' "Invalid MAC address: $1"
        return 1
    fi

    logger -st 'wifi-schedule' "Adding MAC address: $1"
    uci add_list wireless.@wifi-iface[0].maclist="$1"
    uci add_list wireless.@wifi-iface[1].maclist="$1"
}

# Remove all MAC addresses
sed -i '/list maclist/d' /etc/config/wireless

# Add unscheduled MAC addresses
add_mac 'a1:b2:c3:d4:e5:f6' # Laptop
add_mac 'aa:bb:cc:dd:ee:ff' # Phone

# Add scheduled MAC addresses if argument is "up"
if [ "$1" = 'up' ]; then
    add_mac '11:22:33:44:55:66' # Kids tablet
    add_mac '1a:2b:3c:4d:5e:6f' # Nintendo Switch
fi

uci commit wireless
wifi reload

Replace the MAC addresses and save the script at /root/wifi-schedule.sh. Then add this to /etc/crontabs/root:

00 06 * * * /root/wifi-schedule.sh up
00 22 * * * /root/wifi-schedule.sh down

Adjust the on/off time as desired. Your kids will hate it.

Just remember to cancel their data plan.

Seamless Pane-Window Switching Between Tmux and Vim

2022-07-20T15:48:51Z

I can't be arsed with an extra keystroke when switching between windows in vim, so I've had this in my vimrc for years:

" Move the cursor to the next window left/down/up/right
nnoremap <C-H> <C-W><C-H>
nnoremap <C-J> <C-W><C-J>
nnoremap <C-K> <C-W><C-K>
nnoremap <C-L> <C-W><C-L>

And because the arrow keys are a stretch, I have this in my tmux.conf:

# Select the next pane left/down/up/right
bind h selectp -L
bind j selectp -D
bind k selectp -U
bind l selectp -R

With this configuration, jumping out of vim into another tmux pane only requires one extra keystroke: the tmux prefix. Fortunately, Vim Tmux Navigator solves that problem. But it's a bit complicated and messy. Turns out all it requires is a tiny vimscript and a few relatively simple tmux bindings.

Here's the vimscript:

" Only load this plugin if running inside tmux
if empty($TMUX)
    finish
endif

function! NextWindow(direction)
    let l:win_num = winnr()
    execute "wincmd" a:direction

    " If the window number changed, then the command succeeded. Otherwise,
    " we're at an edge window and we'll let tmux handle it.
    if l:win_num != winnr()
        return
    endif

    let l:tmux_direction = tr(a:direction, 'hjkl', 'LDUR')
    call system('tmux select-pane -' . l:tmux_direction)
endfunction

nmap <silent> <C-H> :call NextWindow('h')<CR>
nmap <silent> <C-J> :call NextWindow('j')<CR>
nmap <silent> <C-K> :call NextWindow('k')<CR>
nmap <silent> <C-L> :call NextWindow('l')<CR>

The tmux bindings are a little tricky. At first, I tried this:

bind -n C-h if -F "#{==:#{pane_current_command},nvim}" "send C-h" "selectp -L"

That funky nested format is required for comparing strings in tmux commands. Other than that, it's pretty straightforward. The problem is this doesn't work if vim is used as a pager, is reading from stdin, or was started from a script. In those cases, pane_current_command might be bash, less, man, or whatever command was entered at the command line. Instead, we have to get a list of processes belonging to the terminal attached to the pane:

# If nvim is running in the foreground of the current pane, let it handle these
# keys. Otherwise, select the next pane left/down/up/right.
is_nvim="[ $(ps -o comm -t #{pane_tty} | tail -1) = nvim ]"

bind -n C-h if "$is_nvim" "send C-h" "selectp -L"
bind -n C-j if "$is_nvim" "send C-j" "selectp -D"
bind -n C-k if "$is_nvim" "send C-k" "selectp -U"
bind -n C-l if "$is_nvim" "send C-l" "selectp -R"

Obviously, if you don't use nvim, just change the bindings accordingly.

Finally, if you use emacs-style shortcuts in your shell, you might prefer to use the alt key instead of the control key to keep the default behavior of Ctrl-H (backspace) and Ctrl-K (delete from cursor to end of line). In that case, just replace C- with M- in the vim mappings and the tmux bindings. Also, make sure to use lowercase -h, -j, etc. in the vim mappings due to how vim/xterm handles the alt key.

Better Vim-Style Key Bindings in Tmux

2022-07-15T02:36:34Z

I was confused by tmux's "vi-style" key bindings in copy mode, which don't behave at all like I expected: Space starts the selection (like v in vim), Enter copies and clears the selection (like y), while Ctrl-V toggles block selection mode but doesn't start the selection.

Fortunately, tmux supports braces and conditionals in key bindings. This confused me too because there are two constructs: the %if keyword and the if-shell command.

%if conditions are only evaluated once when the config is loaded. This binding doesn't work because #{selection_present} evaluates to 0 when tmux starts:

bind-key -T copy-mode C-v {
    %if "#{selection_present}"
    display-message yes
    %else
    display-message no
    %endif
}

On the other hand, the if-shell command in this binding will be called every time Ctrl-V is pressed:

bind-key -T copy-mode C-v {
    if-shell -F "#{selection_present}" {
        display-message yes
    } {
        display-message no
    }
}

The -F flag tells tmux to evaluate the condition without calling an external shell command, as the name implies. Otherwise it would try to run 0 or 1 in the shell and fail.

In addition, if-shell commands can be nested, so we can mimic vim's behavior with the following config:

set-option -g mode-keys vi

bind-key -T copy-mode-vi v {
    if-shell -F "#{selection_present}" {
        if-shell -F "#{rectangle_toggle}" {
            send-keys -X rectangle-off
        } {
            send-keys -X clear-selection
        }
    } {
        send-keys -X begin-selection
    }
}

bind-key -T copy-mode-vi C-v {
    if-shell -F "#{selection_present}" {
        if-shell -F "#{rectangle_toggle}" {
            send-keys -X clear-selection
        } {
            send-keys -X rectangle-on
        }
    } {
        send-keys -X begin-selection
        send-keys -X rectangle-on
    }
}

bind-key -T copy-mode-vi y send-keys -X copy-selection-and-cancel

Special Replacements in Sed

2022-07-14T22:15:58Z

I'm exploring a bunch of data in Java. The debugger in IntelliJ is powerful, but I find it much easier to export the data to JSON and use Python. I used GSON to export the data, but the resulting files were full of stuff like this:

"expression": "\u0026sum\u0026 ( ~input~ ) \u003e 0"

I recognized those as unicode escape sequences but didn't know which characters they represented off the top of my head. Typing <Ctrl-V>u0026 into vim inserted an ampersand. Then I turned to sed to fix up the files:

$ sed -i 's/\u0026/&/g' data.json

Which didn't work. Turns out an ampersand means something special to sed:

The replacement may contain the special character & to refer to that portion of the pattern space which matched, and the special escapes \1 through \9 to refer to the corresponding matching sub-expressions in the regexp.

I knew \1 through \9 referred to capturing groups but the & thing surprised me.

The solution is simply to escape the ampersand. However, because \u also means something special (uppercase, I guess), it also has to be escaped:

$ sed -i 's/\\u0026/\&/g' data.json

Turns out awk treats & in replacements the same way. Go figure.

Thanks goes once again to Gilles, whose infinite wisdom has helped me on countless occasions.

The sed manual is available here or with info sed. man sed is lacking in comparison.

Best Practices for Python Unit Testing

2022-05-23T15:25:27Z

First of all, let's distinguish unit testing from integration testing:

A unit test verifies a unit of code in isolation.
An integration test verifies several units of code in conjunction.

Crucially, unit tests should not make network requests, modify database tables, or alter files on disk unless there's an obvious reason for doing so. Unit tests use mocked or stubbed dependencies, optionally verifying that they are called correctly, and make assertions on the results of a single function or module. Integration tests, on the other hand, use concrete dependencies and make assertions on the results of a larger system.

You might disagree on the finer points, but this distinction works well for me.

I won't go over unit testing basics, like how to run pytest or how to use the @patch decorator, assuming you're familiar already.

Avoid module-level globals

Imagine we have a class defined in validator.py:

import os

import fastjsonschema
import requests

schema_url = os.environ['SCHEMA_URL']

class Validator:
    def __init__(self):
        schema = requests.get(schema_url).json()
        self.validator = fastjsonschema.compile(schema)

    def validate(self, event: dict) -> dict:
        return self.validator(event)

And we have a module named my_lambda.py that uses the class:

from validator import Validator

validator = Validator()

def handle_event(event: dict, context: object) -> dict:
    validator.validate(event)
    return {'body': 'Goodbye!', 'status': 200}

And we want to test the module:

from unittest.mock import Mock, patch

from my_lambda import handle_event

@patch('my_lambda.Validator', autospec=True)
def test_handle_event(mock_validator: Mock):
    result = handle_event({'message': 'Hello!'}, None)
    assert result == {'body': 'Goodbye!', 'status': 200}

We're patching the Validator class and not the validator property because the former will allow us to prevent the network request when Validator() is called, whereas the latter would only allow us to act afterwards.

As it's written, this test will fail during collection when my_lambda.py is imported, before the patch is even applied:

test_my_lambda.py:3: in <module>
    from my_lambda import handle_event
my_lambda.py:1: in <module>
    from validator import Validator
validator.py:6: in <module>
    schema_url = os.environ['SCHEMA_URL']
/usr/local/Cellar/python@3.9/3.9.12/Frameworks/Python.framework/Versions/3.9/lib/python3.9/os.py:679: in __getitem__
    raise KeyError(key) from None
E   KeyError: 'SCHEMA_URL'

We could set SCHEMA_URL in our .env file, but that's an extra step that would be required for every developer to run the test. Instead, let's try setting it right before the import:

import os

from unittest.mock import Mock, patch

os.environ['SCHEMA_URL'] = 'foo'

from my_lambda import handle_event

This will also fail during collection:

test_my_lambda.py:7: in <module>
    from my_lambda import handle_event
my_lambda.py:3: in <module>
    validator = Validator()
validator.py:10: in __init__
    schema = requests.get(schema_url).json()
...
E   requests.exceptions.MissingSchema: Invalid URL 'foo': No scheme supplied. Perhaps you meant http://foo?

Even though we're patching the Validator class, it's still trying to make a network request because Validator() is called when my_lambda.py is imported, before the patch is even applied. If I sound like a broken record, it's because this can be confusing:

Module-level globals are assigned when the module is imported, which makes them difficult to patch.

The correct way to fix this problem is to eliminate the global from my_lambda.py:

from validator import Validator

def handle_event(event: dict, context: object):
    validator = Validator()
    validator.validate(event)

Now the test passes, but it's kind of ugly. Let's remove another global, this time from validator.py:

import os

import fastjsonschema
import requests

class Validator:
    def __init__(self):
        schema_url = os.environ['SCHEMA_URL']
        schema = requests.get(schema_url).json()
        self.validator = fastjsonschema.compile(schema)

    def validate(self, event: dict) -> dict:
        return self.validator(event)

This allows us to simplify the test, restoring it to its original form:

from unittest.mock import Mock, patch

from my_lambda import handle_event

@patch('my_lambda.Validator', autospec=True)
def test_handle_event(mock_validator: Mock):
    result = handle_event({'message': 'Hello!'}, None)
    assert result == {'body': 'Goodbye!', 'status': 200}

Globals aren't always bad

If you must use a global for some reason, set it to None initially:

from typing import Optional

from validator import Validator

validator: Optional[Validator] = None

def handle_event(event: dict, context: object):
    global validator

    if not validator:
        validator = Validator()

    validator.validate(event)

The key is to prevent any expensive computation or network requests when the module is imported to facilitate patching.

Use dependency injection

Next, let's test the class:

from validator import Validator

def test_validator_init():
    result = Validator()
    assert result.validator is not None

This test will fail unless SCHEMA_URL is defined in the environment. As previously mentioned, we could add it to our .env file, or we could set it directly like we did before with os.environ['SCHEMA_URL'] = 'foo'. It's better to use the @patch.dict decorator because it will restore the original value after the test exits:

import os

from unittest.mock import patch

from validator import Validator

@patch.dict(os.environ, {'SCHEMA_URL': 'foo'})
def test_validator_init():
    result = Validator()
    assert result.validator is not None

Either way, this test will fail because it's trying to make a network request to an invalid URL:

validator.py:9: in __init__
    schema = requests.get(schema_url).json()
...
E   requests.exceptions.MissingSchema: Invalid URL 'foo': No scheme supplied. Perhaps you meant http://foo?

Again, we want to prevent the network request. This is where dependency injection, also known as inversion of control, comes in handy. Let's refactor validator.py to accept a few arguments:

import os

from typing import Callable, Optional

import fastjsonschema
import requests

class Validator:
    def __init__(
        self,
        validator: Optional[Callable[[dict], dict]] = None,
        schema: Optional[dict] = None,
        schema_url: Optional[str] = None,
    ):
        if validator:
            self.validator = validator
            return

        if schema:
            self.validator = fastjsonschema.compile(schema)
            return

        if not schema_url:
            schema_url = os.environ['SCHEMA_URL']

        schema = requests.get(schema_url).json()
        self.validator = fastjsonschema.compile(schema)

    def validate(self, event: dict) -> dict:
        return self.validator(event)

It's worth a moment to understand what's happening here when Validator() is called:

If called with a validator argument, that argument is assigned to self.validator. Any other arguments are ignored.
If called with a schema argument, that argument is used to create self.validator.
If called with a schema_url argument, the schema is requested from the URL, the response is parsed and used to create self.validator.
If called without any arguments, the schema is requested from the URL specified in the environment.

This allows us to easily prevent the network request when running the unit test:

import os

from unittest.mock import Mock, patch

from validator import Validator

def test_validator_init_with_validator():
    mock_validator = Mock()

    result = Validator(validator=mock_validator)
    assert result.validator == mock_validator

The downside is we need to cover the additional complexity in the constructor. Fortunately, it can be accomplished with some straightforward patching:

@patch('fastjsonschema.compile', autospec=True)
def test_validator_init_with_schema(mock_compile):
    mock_validator = Mock()
    mock_compile.return_value = mock_validator

    result = Validator(schema={'type': 'string'})
    assert result.validator == mock_validator

@patch('fastjsonschema.compile', autospec=True)
@patch('requests.get', autospec=True)
def test_validator_init_with_schema_url(mock_get, mock_compile):
    mock_schema = Mock()
    mock_get.return_value.json.return_value = mock_schema

    mock_validator = Mock()
    mock_compile.return_value = mock_validator

    result = Validator(schema_url='foo')
    assert result.validator == mock_validator

    mock_get.assert_called_once_with('foo')

@patch('fastjsonschema.compile', autospec=True)
@patch('requests.get', autospec=True)
@patch.dict(os.environ, {'SCHEMA_URL': 'bar'})
def test_validator_init_with_no_args(mock_get, mock_compile):
    mock_schema = Mock()
    mock_get.return_value.json.return_value = mock_schema

    mock_validator = Mock()
    mock_compile.return_value = mock_validator

    result = Validator()
    assert result.validator == mock_validator

    mock_get.assert_called_once_with('bar')

def test_validator_validate():
    mock_validator = Mock()
    mock_validator.return_value = 42

    validator = Validator(mock_validator)

    result = validator.validate({})
    assert result == 42

This last unit test is dirt simple because we don't really care how fastjsonschema is implemented. It has its own unit tests.

This article was cross-posted on Dice.com.