diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index afe2123..ab7509c 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,22 +1,22 @@
 version: 2
 updates:
-- package-ecosystem: "github-actions"
-  directory: "/"
-  schedule:
-    interval: "monthly"
-  labels:
-  - "component/dependencies"
+    -   package-ecosystem: "github-actions"
+        directory: "/"
+        schedule:
+            interval: "monthly"
+        labels:
+            - "component/dependencies"
 
-- package-ecosystem: "gomod"
-  directory: "/"
-  schedule:
-    interval: "monthly"
-  labels:
-  - "component/dependencies"
+    -   package-ecosystem: "gomod"
+        directory: "/"
+        schedule:
+            interval: "monthly"
+        labels:
+            - "component/dependencies"
 
-- package-ecosystem: "docker"
-  directory: "/"
-  schedule:
-    interval: "monthly"
-  labels:
-  - "component/dependencies"
+    -   package-ecosystem: "docker"
+        directory: "/"
+        schedule:
+            interval: "monthly"
+        labels:
+            - "component/dependencies"
diff --git a/.github/workflows/CI.yaml b/.github/workflows/CI.yaml
index 62beb62..4985f5d 100644
--- a/.github/workflows/CI.yaml
+++ b/.github/workflows/CI.yaml
@@ -1,115 +1,115 @@
 name: CI
 on:
-  # See the documentation for more intricate event dispatch here:
-  # https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions#on
-  push:
-    branches:
-    - "!dependabot/*"
-    - "*"
-  pull_request:
-    branches:
-    - "*"
+    # See the documentation for more intricate event dispatch here:
+    # https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions#on
+    push:
+        branches:
+            - "!dependabot/*"
+            - "*"
+    pull_request:
+        branches:
+            - "*"
 jobs:
-  build:
-    name: Build & Lint
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Setup
-      uses: actions/setup-go@v2
-      with:
-        go-version: ^1.15
-    - name: Build
-      run: go build -v ./cmd/...
-    - name: Vet
-      run: go vet ./...
-    - name: Imports
-      uses: Jerome1337/goimports-action@v1.0.3
-    - name: Format
-      uses: Jerome1337/gofmt-action@v1.0.4
-    - name: Lint
-      uses: Jerome1337/golint-action@v1.0.2
+    build:
+        name: Build & Lint
+        runs-on: ubuntu-latest
+        steps:
+            -   name: Checkout
+                uses: actions/checkout@v2
+            -   name: Setup
+                uses: actions/setup-go@v2
+                with:
+                    go-version: ^1.15
+            -   name: Build
+                run: go build -v ./cmd/...
+            -   name: Vet
+                run: go vet ./...
+            -   name: Imports
+                uses: Jerome1337/goimports-action@v1.0.3
+            -   name: Format
+                uses: Jerome1337/gofmt-action@v1.0.4
+            -   name: Lint
+                uses: Jerome1337/golint-action@v1.0.2
 
-  unit:
-    name: Unit Tests
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Setup
-      uses: actions/setup-go@v2
-      with:
-        go-version: ^1.15
-    - name: Unit Tests
-      run: go test -v -race $(go list ./...)
+    unit:
+        name: Unit Tests
+        runs-on: ubuntu-latest
+        steps:
+            -   name: Checkout
+                uses: actions/checkout@v2
+            -   name: Setup
+                uses: actions/setup-go@v2
+                with:
+                    go-version: ^1.15
+            -   name: Unit Tests
+                run: go test -v -race $(go list ./...)
 
-  e2e-mem:
-    name: E2E Tests (Memory Storage)
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Setup
-      uses: actions/setup-go@v2
-      with:
-        go-version: ^1.15
-    - name: End-to-End Test
-      run: |
-        go install --tags e2e ./cmd/chihaya
-        cat ./dist/example_config.yaml
-        chihaya --config=./dist/example_config.yaml --debug &
-        pid=$!
-        sleep 2
-        chihaya e2e --debug
-        kill $pid
+    e2e-mem:
+        name: E2E Tests (Memory Storage)
+        runs-on: ubuntu-latest
+        steps:
+            -   name: Checkout
+                uses: actions/checkout@v2
+            -   name: Setup
+                uses: actions/setup-go@v2
+                with:
+                    go-version: ^1.15
+            -   name: End-to-End Test
+                run: |
+                    go install --tags e2e ./cmd/chihaya
+                    cat ./dist/example_config.yaml
+                    chihaya --config=./dist/example_config.yaml --debug &
+                    pid=$!
+                    sleep 2
+                    chihaya e2e --debug
+                    kill $pid
 
-  e2e-redis:
-    name: E2E Tests (Redis Storage)
-    runs-on: ubuntu-latest
-    services:
-      redis:
-        image: redis
-        ports: ["6379:6379"]
-        options: --entrypoint redis-server
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Setup
-      uses: actions/setup-go@v2
-      with:
-        go-version: ^1.15
-    - name: Configure redis storage
-      run: |
-        curl -LO https://github.com/jzelinskie/faq/releases/download/0.0.6/faq-linux-amd64
-        chmod +x faq-linux-amd64
-        ./faq-linux-amd64 '.chihaya.storage = {"config":{"gc_interval":"3m","peer_lifetime":"31m","prometheus_reporting_interval":"1s","redis_broker":"redis://127.0.0.1:6379/0","redis_connect_timeout":"15s","redis_read_timeout":"15s","redis_write_timeout":"15s"},"name":"redis"}' ./dist/example_config.yaml > ./dist/example_redis_config.yaml
-        cat ./dist/example_redis_config.yaml
-    - name: End-to-End Test
-      run: |
-        go install --tags e2e ./cmd/chihaya
-        chihaya --config=./dist/example_redis_config.yaml --debug &
-        pid=$!
-        sleep 2
-        chihaya e2e --debug
-        kill $pid
+    e2e-redis:
+        name: E2E Tests (Redis Storage)
+        runs-on: ubuntu-latest
+        services:
+            redis:
+                image: redis
+                ports: [ "6379:6379" ]
+                options: --entrypoint redis-server
+        steps:
+            -   name: Checkout
+                uses: actions/checkout@v2
+            -   name: Setup
+                uses: actions/setup-go@v2
+                with:
+                    go-version: ^1.15
+            -   name: Configure redis storage
+                run: |
+                    curl -LO https://github.com/jzelinskie/faq/releases/download/0.0.6/faq-linux-amd64
+                    chmod +x faq-linux-amd64
+                    ./faq-linux-amd64 '.chihaya.storage = {"config":{"gc_interval":"3m","peer_lifetime":"31m","prometheus_reporting_interval":"1s","redis_broker":"redis://127.0.0.1:6379/0","redis_connect_timeout":"15s","redis_read_timeout":"15s","redis_write_timeout":"15s"},"name":"redis"}' ./dist/example_config.yaml > ./dist/example_redis_config.yaml
+                    cat ./dist/example_redis_config.yaml
+            -   name: End-to-End Test
+                run: |
+                    go install --tags e2e ./cmd/chihaya
+                    chihaya --config=./dist/example_redis_config.yaml --debug &
+                    pid=$!
+                    sleep 2
+                    chihaya e2e --debug
+                    kill $pid
 
-  dist:
-    name: Helm Template
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Install Helm
-      uses: engineerd/configurator@v0.0.5
-      with:
-        name: helm
-        pathInArchive: linux-amd64/helm
-        fromGitHubReleases: true
-        repo: helm/helm
-        version: ^v3
-        urlTemplate: https://get.helm.sh/helm-{{version}}-linux-amd64.tar.gz
-        token: ${{ secrets.GITHUB_TOKEN }}
-    - name: Helm Template
-      working-directory: ./dist/helm/chihaya
-      run: helm template . --debug
+    dist:
+        name: Helm Template
+        runs-on: ubuntu-latest
+        steps:
+            -   name: Checkout
+                uses: actions/checkout@v2
+            -   name: Install Helm
+                uses: engineerd/configurator@v0.0.5
+                with:
+                    name: helm
+                    pathInArchive: linux-amd64/helm
+                    fromGitHubReleases: true
+                    repo: helm/helm
+                    version: ^v3
+                    urlTemplate: https://get.helm.sh/helm-{{version}}-linux-amd64.tar.gz
+                    token: ${{ secrets.GITHUB_TOKEN }}
+            -   name: Helm Template
+                working-directory: ./dist/helm/chihaya
+                run: helm template . --debug
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index adbf076..a8d0459 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,26 +1,26 @@
 ## Discussion
 
-Long-term discussion and bug reports are maintained via [GitHub Issues].
-Code review is done via [GitHub Pull Requests].
+Long-term discussion and bug reports are maintained via [GitHub Issues]. Code review is done via [GitHub Pull Requests].
 Real-time discussion is done via [freenode IRC].
 
 [GitHub Issues]: https://github.com/chihaya/chihaya/issues
+
 [GitHub Pull Requests]: https://github.com/chihaya/chihaya/pulls
+
 [freenode IRC]: http://webchat.freenode.net/?channels=chihaya
 
 ## Pull Request Procedure
 
-If you're looking to contribute, search the GitHub for issues labeled "low-hanging fruit".
-You can also hop into IRC and ask a developer who's online for their opinion.
+If you're looking to contribute, search the GitHub for issues labeled "low-hanging fruit". You can also hop into IRC and
+ask a developer who's online for their opinion.
 
-Small, self-describing fixes are perfectly fine to submit without discussion.
-However, please do not submit a massive Pull Request without prior communication.
-Large, unannounced changes usually lead to confusion and time wasted for everyone.
-If you were planning to write a large change, post an issue on GitHub first and discuss it.
+Small, self-describing fixes are perfectly fine to submit without discussion. However, please do not submit a massive
+Pull Request without prior communication. Large, unannounced changes usually lead to confusion and time wasted for
+everyone. If you were planning to write a large change, post an issue on GitHub first and discuss it.
 
-Pull Requests will be treated as "review requests", and we will give feedback we expect to see corrected on style and substance before merging.
-Changes contributed via Pull Request should focus on a single issue at a time.
-We will not accept pull-requests that try to "sneak" unrelated changes in.
+Pull Requests will be treated as "review requests", and we will give feedback we expect to see corrected on style and
+substance before merging. Changes contributed via Pull Request should focus on a single issue at a time. We will not
+accept pull-requests that try to "sneak" unrelated changes in.
 
 The average contribution flow is as follows:
 
@@ -41,19 +41,23 @@ Any new files should include the license header found at the top of every source
 
 ### Go
 
-The project follows idiomatic [Go conventions] for style.
-If you're just starting out writing Go, you can check out this [meta-package] that documents style idiomatic style decisions you will find in open source Go code.
-All files should have `gofmt` executed on them and code should strive to have full coverage of static analysis tools like [govet] and [golint].
+The project follows idiomatic [Go conventions] for style. If you're just starting out writing Go, you can check out
+this [meta-package] that documents style idiomatic style decisions you will find in open source Go code. All files
+should have `gofmt` executed on them and code should strive to have full coverage of static analysis tools like [govet]
+and [golint].
 
 [Go conventions]: https://github.com/golang/go/wiki/CodeReviewComments
+
 [meta-package]: https://github.com/jzelinskie/conventions
+
 [govet]: https://golang.org/cmd/vet
+
 [golint]: https://github.com/golang/lint
 
 ### Commit Messages
 
-We follow a rough convention for commit messages that is designed to answer two questions: what changed and why.
-The subject line should feature the what and the body of the commit should describe the why.
+We follow a rough convention for commit messages that is designed to answer two questions: what changed and why. The
+subject line should feature the what and the body of the commit should describe the why.
 
 ```
 scripts: add the test-cluster command
@@ -74,5 +78,6 @@ The format can be described more formally as follows:
 <footer>
 ```
 
-The first line is the subject and should be no longer than 70 characters, the second line is always blank, and other lines should be wrapped at 80 characters.
-This allows the message to be easier to read on GitHub as well as in various git tools.
+The first line is the subject and should be no longer than 70 characters, the second line is always blank, and other
+lines should be wrapped at 80 characters. This allows the message to be easier to read on GitHub as well as in various
+git tools.
diff --git a/README.md b/README.md
index 6efc440..0a89482 100644
--- a/README.md
+++ b/README.md
@@ -18,43 +18,52 @@ Differentiating features include:
 - High Availability via [Redis]
 - Kubernetes deployment via [Helm]
 
-**Note:** The master branch may be in an unstable or even broken state during development.
-Please use [releases] instead of the master branch in order to get stable binaries.
+**Note:** The master branch may be in an unstable or even broken state during development. Please use [releases] instead
+of the master branch in order to get stable binaries.
 
 [releases]: https://github.com/chihaya/chihaya/releases
+
 [BitTorrent tracker]: https://en.wikipedia.org/wiki/BitTorrent_tracker
+
 [Go]: https://golang.org
+
 [YAML]: https://yaml.org
+
 [Prometheus]: https://prometheus.io
+
 [Redis]: https://redis.io
+
 [Helm]: https://helm.sh
 
 ## Why Chihaya?
 
-Chihaya is built for developers looking to integrate BitTorrent into a preexisting production environment.
-Chihaya's pluggable architecture and middleware framework offers a simple and flexible integration point that abstracts the BitTorrent tracker protocols.
-The most common use case for Chihaya is enabling peer-to-peer cloud software deployments.
+Chihaya is built for developers looking to integrate BitTorrent into a preexisting production environment. Chihaya's
+pluggable architecture and middleware framework offers a simple and flexible integration point that abstracts the
+BitTorrent tracker protocols. The most common use case for Chihaya is enabling peer-to-peer cloud software deployments.
 
 ## Development
 
 ### Contributing
 
-Long-term discussion and bug reports are maintained via [GitHub Issues].
-Code review is done via [GitHub Pull Requests].
+Long-term discussion and bug reports are maintained via [GitHub Issues]. Code review is done via [GitHub Pull Requests].
 Real-time discussion is done via [freenode IRC].
 
 For more information read [CONTRIBUTING.md].
 
 [GitHub Issues]: https://github.com/chihaya/chihaya/issues
+
 [GitHub Pull Requests]: https://github.com/chihaya/chihaya/pulls
+
 [freenode IRC]: http://webchat.freenode.net/?channels=chihaya
+
 [CONTRIBUTING.md]: https://github.com/chihaya/chihaya/blob/master/CONTRIBUTING.md
 
 ### Getting Started
 
 #### Building from HEAD
 
-In order to compile the project, the [latest stable version of Go] and knowledge of a [working Go environment] are required.
+In order to compile the project, the [latest stable version of Go] and knowledge of a [working Go environment] are
+required.
 
 ```sh
 $ git clone git@github.com:chihaya/chihaya.git
@@ -64,6 +73,7 @@ $ ./chihaya --help
 ```
 
 [latest stable version of Go]: https://golang.org/dl
+
 [working Go environment]: https://golang.org/doc/code.html
 
 #### Docker
@@ -71,19 +81,18 @@ $ ./chihaya --help
 Docker containers are available for [HEAD] and [stable] releases.
 
 [HEAD]: https://quay.io/jzelinskie/chihaya-git
+
 [stable]: https://quay.io/jzelinskie/chihaya
 
 #### Testing
 
-The following will run all tests and benchmarks.
-Removing `-bench` will just run unit tests.
+The following will run all tests and benchmarks. Removing `-bench` will just run unit tests.
 
 ```sh
 $ go test -bench $(go list ./...)
 ```
 
-The Chihaya executable contains a command to end-to-end test a BitTorrent tracker.
-See
+The Chihaya executable contains a command to end-to-end test a BitTorrent tracker. See
 
 ```sh
 $ chihaya --help
@@ -91,12 +100,13 @@ $ chihaya --help
 
 ### Configuration
 
-Configuration of Chihaya is done via one YAML configuration file.
-The `dist/` directory contains an example configuration file.
-Files and directories under `docs/` contain detailed information about configuring middleware, storage implementations, architecture etc.
+Configuration of Chihaya is done via one YAML configuration file. The `dist/` directory contains an example
+configuration file. Files and directories under `docs/` contain detailed information about configuring middleware,
+storage implementations, architecture etc.
 
 ## Related projects
 
-- [BitTorrent.org](https://github.com/bittorrent/bittorrent.org): a static website containing the BitTorrent spec and all BEPs
+- [BitTorrent.org](https://github.com/bittorrent/bittorrent.org): a static website containing the BitTorrent spec and
+  all BEPs
 - [OpenTracker](http://erdgeist.org/arts/software/opentracker): a popular BitTorrent tracker written in C
 - [Ocelot](https://github.com/WhatCD/Ocelot): a private BitTorrent tracker written in C++
diff --git a/bittorrent/bittorrent.go b/bittorrent/bittorrent.go
index 7551880..5c4eba0 100644
--- a/bittorrent/bittorrent.go
+++ b/bittorrent/bittorrent.go
@@ -6,6 +6,7 @@ package bittorrent
 import (
 	"crypto/sha1"
 	"crypto/sha256"
+	"encoding/hex"
 	"fmt"
 	"github.com/pkg/errors"
 	"net"
@@ -35,7 +36,7 @@ func NewPeerID(b []byte) (PeerID, error) {
 
 // String implements fmt.Stringer, returning the base16 encoded PeerID.
 func (p PeerID) String() string {
-	return fmt.Sprintf("%x", p[:])
+	return hex.EncodeToString(p[:])
 }
 
 // RawString returns a 20-byte string of the raw bytes of the ID.
@@ -52,6 +53,7 @@ const (
 	NoneInfoHash  InfoHash = ""
 )
 
+var InvalidHashTypeError = errors.New("info hash must be provided as byte slice or raw/hex string")
 var InvalidHashSizeError = errors.New("info hash must be either 20 (for torrent V1) or 32 (V2) bytes")
 
 // TruncateV1 returns truncated to 20-bytes length array of the corresponding InfoHash.
@@ -61,30 +63,42 @@ func (i InfoHash) TruncateV1() InfoHash {
 	return i[:InfoHashV1Len]
 }
 
-// ValidateInfoHash validates input bytes size and returns it
-// if size one of InfoHashV1Len or InfoHashV2Len.
-// In other case 0 and non-nil error returned
-func ValidateInfoHash(b []byte) (int, error) {
-	l := len(b)
-	if l != InfoHashV1Len && l != InfoHashV2Len {
-		return 0, InvalidHashSizeError
+// NewInfoHash creates an InfoHash from a byte slice or raw/hex string.
+func NewInfoHash(b interface{}) (InfoHash, error) {
+	if b == nil {
+		return NoneInfoHash, InvalidHashTypeError
 	}
-	return l, nil
-}
-
-// NewInfoHash creates an InfoHash from a byte slice.
-func NewInfoHash(b []byte) (InfoHash, error) {
-	if _, err := ValidateInfoHash(b); err != nil {
-		return NoneInfoHash, err
+	var ba []byte
+	switch t := b.(type) {
+	case [InfoHashV1Len]byte:
+		ba = t[:]
+	case [InfoHashV2Len]byte:
+		ba = t[:]
+	case []byte:
+		ba = t
+	case string:
+		l := len(t)
+		if l == InfoHashV1Len*2 || l == InfoHashV2Len*2 {
+			var err error
+			if ba, err = hex.DecodeString(t); err != nil {
+				return NoneInfoHash, err
+			}
+		} else {
+			ba = []byte(t)
+		}
+	}
+	l := len(ba)
+	if l != InfoHashV1Len && l != InfoHashV2Len {
+		return NoneInfoHash, InvalidHashSizeError
 	} else {
-		buf := InfoHash(b)
+		buf := InfoHash(ba)
 		return buf, nil
 	}
 }
 
 // String implements fmt.Stringer, returning the base16 encoded InfoHash.
 func (i InfoHash) String() string {
-	return fmt.Sprintf("%x", i[:])
+	return hex.EncodeToString([]byte(i))
 }
 
 // RawString returns a string of the raw bytes of the InfoHash.
diff --git a/bittorrent/params.go b/bittorrent/params.go
index 0cc7496..c5c7e34 100644
--- a/bittorrent/params.go
+++ b/bittorrent/params.go
@@ -168,7 +168,7 @@ func parseQuery(query string) (q *QueryParams, err error) {
 		}
 
 		if key == "info_hash" {
-			if ih, err := NewInfoHash([]byte(value)); err == nil {
+			if ih, err := NewInfoHash(value); err == nil {
 				q.infoHashes = append(q.infoHashes, ih)
 			} else {
 				return nil, err
diff --git a/dist/example_config.yaml b/dist/example_config.yaml
index c1afcc7..61c81d6 100644
--- a/dist/example_config.yaml
+++ b/dist/example_config.yaml
@@ -1,196 +1,196 @@
 chihaya:
-  # The interval communicated with BitTorrent clients informing them how
-  # frequently they should announce in between client events.
-  announce_interval: 30m
+    # The interval communicated with BitTorrent clients informing them how
+    # frequently they should announce in between client events.
+    announce_interval: 30m
 
-  # The interval communicated with BitTorrent clients informing them of the
-  # minimal duration between announces.
-  min_announce_interval: 15m
+    # The interval communicated with BitTorrent clients informing them of the
+    # minimal duration between announces.
+    min_announce_interval: 15m
 
-  # The network interface that will bind to an HTTP endpoint that can be
-  # scraped by programs collecting metrics.
-  # 
-  # /metrics serves metrics in the Prometheus format
-  # /debug/pprof/{cmdline,profile,symbol,trace} serves profiles in the pprof format
-  metrics_addr: "0.0.0.0:6880"
-
-  # This block defines configuration for the tracker's HTTP interface.
-  # If you do not wish to run this, delete this section.
-  http:
-    # The network interface that will bind to an HTTP server for serving
-    # BitTorrent traffic. Remove this to disable the non-TLS listener.
-    addr: "0.0.0.0:6969"
-
-    # The network interface that will bind to an HTTPS server for serving
-    # BitTorrent traffic. If set, tls_cert_path and tls_key_path are required.
-    https_addr: ""
-
-    # The path to the required files to listen via HTTPS.
-    tls_cert_path: ""
-    tls_key_path: ""
-
-    # The timeout durations for HTTP requests.
-    read_timeout: 5s
-    write_timeout: 5s
-
-    # When true, persistent connections will be allowed. Generally this is not
-    # useful for a public tracker, but helps performance in some cases (use of
-    # a reverse proxy, or when there are few clients issuing many requests).
-    enable_keepalive: false
-    idle_timeout: 30s
-
-    # Whether to time requests.
-    # Disabling this should increase performance/decrease load.
-    enable_request_timing: false
-
-    # An array of routes to listen on for announce requests. This is an option
-    # to support trackers that do not listen for /announce or need to listen
-    # on multiple routes.
+    # The network interface that will bind to an HTTP endpoint that can be
+    # scraped by programs collecting metrics.
     #
-    # This supports named parameters and catch-all parameters as described at
-    # https://github.com/julienschmidt/httprouter#named-parameters
-    announce_routes:
-      - "/announce"
-      # - "/announce.php"
+    # /metrics serves metrics in the Prometheus format
+    # /debug/pprof/{cmdline,profile,symbol,trace} serves profiles in the pprof format
+    metrics_addr: "0.0.0.0:6880"
 
-    # An array of routes to listen on for scrape requests. This is an option
-    # to support trackers that do not listen for /scrape or need to listen
-    # on multiple routes.
-    #
-    # This supports named parameters and catch-all parameters as described at
-    # https://github.com/julienschmidt/httprouter#named-parameters
-    scrape_routes:
-      - "/scrape"
-      # - "/scrape.php"
+    # This block defines configuration for the tracker's HTTP interface.
+    # If you do not wish to run this, delete this section.
+    http:
+        # The network interface that will bind to an HTTP server for serving
+        # BitTorrent traffic. Remove this to disable the non-TLS listener.
+        addr: "0.0.0.0:6969"
 
-    # When enabled, the IP address used to connect to the tracker will not
-    # override the value clients advertise as their IP address.
-    allow_ip_spoofing: false
+        # The network interface that will bind to an HTTPS server for serving
+        # BitTorrent traffic. If set, tls_cert_path and tls_key_path are required.
+        https_addr: ""
 
-    # The HTTP Header containing the IP address of the client.
-    # This is only necessary if using a reverse proxy.
-    real_ip_header: "x-real-ip"
+        # The path to the required files to listen via HTTPS.
+        tls_cert_path: ""
+        tls_key_path: ""
 
-    # The maximum number of peers returned for an individual request.
-    max_numwant: 100
+        # The timeout durations for HTTP requests.
+        read_timeout: 5s
+        write_timeout: 5s
 
-    # The default number of peers returned for an individual request.
-    default_numwant: 50
+        # When true, persistent connections will be allowed. Generally this is not
+        # useful for a public tracker, but helps performance in some cases (use of
+        # a reverse proxy, or when there are few clients issuing many requests).
+        enable_keepalive: false
+        idle_timeout: 30s
 
-    # The maximum number of infohashes that can be scraped in one request.
-    max_scrape_infohashes: 50
+        # Whether to time requests.
+        # Disabling this should increase performance/decrease load.
+        enable_request_timing: false
 
-  # This block defines configuration for the tracker's UDP interface.
-  # If you do not wish to run this, delete this section.
-  udp:
-    # The network interface that will bind to a UDP server for serving
-    # BitTorrent traffic.
-    addr: "0.0.0.0:6969"
+        # An array of routes to listen on for announce requests. This is an option
+        # to support trackers that do not listen for /announce or need to listen
+        # on multiple routes.
+        #
+        # This supports named parameters and catch-all parameters as described at
+        # https://github.com/julienschmidt/httprouter#named-parameters
+        announce_routes:
+            - "/announce"
+            # - "/announce.php"
 
-    # The leeway for a timestamp on a connection ID.
-    max_clock_skew: 10s
+        # An array of routes to listen on for scrape requests. This is an option
+        # to support trackers that do not listen for /scrape or need to listen
+        # on multiple routes.
+        #
+        # This supports named parameters and catch-all parameters as described at
+        # https://github.com/julienschmidt/httprouter#named-parameters
+        scrape_routes:
+            - "/scrape"
+            # - "/scrape.php"
 
-    # The key used to encrypt connection IDs.
-    private_key: "paste a random string here that will be used to hmac connection IDs"
+        # When enabled, the IP address used to connect to the tracker will not
+        # override the value clients advertise as their IP address.
+        allow_ip_spoofing: false
 
-    # Whether to time requests.
-    # Disabling this should increase performance/decrease load.
-    enable_request_timing: false
+        # The HTTP Header containing the IP address of the client.
+        # This is only necessary if using a reverse proxy.
+        real_ip_header: "x-real-ip"
 
-    # When enabled, the IP address used to connect to the tracker will not
-    # override the value clients advertise as their IP address.
-    allow_ip_spoofing: false
+        # The maximum number of peers returned for an individual request.
+        max_numwant: 100
 
-    # The maximum number of peers returned for an individual request.
-    max_numwant: 100
+        # The default number of peers returned for an individual request.
+        default_numwant: 50
 
-    # The default number of peers returned for an individual request.
-    default_numwant: 50
+        # The maximum number of infohashes that can be scraped in one request.
+        max_scrape_infohashes: 50
 
-    # The maximum number of infohashes that can be scraped in one request.
-    max_scrape_infohashes: 50
+    # This block defines configuration for the tracker's UDP interface.
+    # If you do not wish to run this, delete this section.
+    udp:
+        # The network interface that will bind to a UDP server for serving
+        # BitTorrent traffic.
+        addr: "0.0.0.0:6969"
+
+        # The leeway for a timestamp on a connection ID.
+        max_clock_skew: 10s
+
+        # The key used to encrypt connection IDs.
+        private_key: "paste a random string here that will be used to hmac connection IDs"
+
+        # Whether to time requests.
+        # Disabling this should increase performance/decrease load.
+        enable_request_timing: false
+
+        # When enabled, the IP address used to connect to the tracker will not
+        # override the value clients advertise as their IP address.
+        allow_ip_spoofing: false
+
+        # The maximum number of peers returned for an individual request.
+        max_numwant: 100
+
+        # The default number of peers returned for an individual request.
+        default_numwant: 50
+
+        # The maximum number of infohashes that can be scraped in one request.
+        max_scrape_infohashes: 50
 
 
-  # This block defines configuration used for the storage of peer data.
-  storage:
-    name: memory
-    config:
-      # The frequency which stale peers are removed.
-      # This balances between
-      # - collecting garbage more often, potentially using more CPU time, but potentially using less memory (lower value)
-      # - collecting garbage less frequently, saving CPU time, but keeping old peers long, thus using more memory (higher value).
-      gc_interval: 3m
+    # This block defines configuration used for the storage of peer data.
+    storage:
+        name: memory
+        config:
+            # The frequency which stale peers are removed.
+            # This balances between
+            # - collecting garbage more often, potentially using more CPU time, but potentially using less memory (lower value)
+            # - collecting garbage less frequently, saving CPU time, but keeping old peers long, thus using more memory (higher value).
+            gc_interval: 3m
 
-      # The amount of time until a peer is considered stale.
-      # To avoid churn, keep this slightly larger than `announce_interval`
-      peer_lifetime: 31m
+            # The amount of time until a peer is considered stale.
+            # To avoid churn, keep this slightly larger than `announce_interval`
+            peer_lifetime: 31m
 
-      # The number of partitions data will be divided into in order to provide a
-      # higher degree of parallelism.
-      shard_count: 1024
+            # The number of partitions data will be divided into in order to provide a
+            # higher degree of parallelism.
+            shard_count: 1024
 
-      # The interval at which metrics about the number of infohashes and peers
-      # are collected and posted to Prometheus.
-      prometheus_reporting_interval: 1s
+            # The interval at which metrics about the number of infohashes and peers
+            # are collected and posted to Prometheus.
+            prometheus_reporting_interval: 1s
 
-  # This block defines configuration used for redis storage.
-  # storage:
-  #   name: redis
-  #   config:
-  #     # The frequency which stale peers are removed.
-  #     # This balances between
-  #     # - collecting garbage more often, potentially using more CPU time, but potentially using less memory (lower value)
-  #     # - collecting garbage less frequently, saving CPU time, but keeping old peers long, thus using more memory (higher value).
-  #     gc_interval: 3m
+    # This block defines configuration used for redis storage.
+    # storage:
+    #   name: redis
+    #   config:
+    #     # The frequency which stale peers are removed.
+    #     # This balances between
+    #     # - collecting garbage more often, potentially using more CPU time, but potentially using less memory (lower value)
+    #     # - collecting garbage less frequently, saving CPU time, but keeping old peers long, thus using more memory (higher value).
+    #     gc_interval: 3m
 
-  #     # The interval at which metrics about the number of infohashes and peers
-  #     # are collected and posted to Prometheus.
-  #     prometheus_reporting_interval: 1s
+    #     # The interval at which metrics about the number of infohashes and peers
+    #     # are collected and posted to Prometheus.
+    #     prometheus_reporting_interval: 1s
 
-  #     # The amount of time until a peer is considered stale.
-  #     # To avoid churn, keep this slightly larger than `announce_interval`
-  #     peer_lifetime: 31m
+    #     # The amount of time until a peer is considered stale.
+    #     # To avoid churn, keep this slightly larger than `announce_interval`
+    #     peer_lifetime: 31m
 
-  #     # The address of redis storage.
-  #     redis_broker: "redis://pwd@127.0.0.1:6379/0"
+    #     # The address of redis storage.
+    #     redis_broker: "redis://pwd@127.0.0.1:6379/0"
 
-  #     # The timeout for reading a command reply from redis.
-  #     redis_read_timeout: 15s
+    #     # The timeout for reading a command reply from redis.
+    #     redis_read_timeout: 15s
 
-  #     # The timeout for writing a command to redis.
-  #     redis_write_timeout: 15s
+    #     # The timeout for writing a command to redis.
+    #     redis_write_timeout: 15s
 
-  #     # The timeout for connecting to redis server.
-  #     redis_connect_timeout: 15s
+    #     # The timeout for connecting to redis server.
+    #     redis_connect_timeout: 15s
 
-  # This block defines configuration used for middleware executed before a
-  # response has been returned to a BitTorrent client.
-  prehooks:
-  #- name: jwt
-  #  options:
-  #    issuer: "https://issuer.com"
-  #    audience: "https://chihaya.issuer.com"
-  #    jwk_set_url: "https://issuer.com/keys"
-  #    jwk_set_update_interval: 5m
+    # This block defines configuration used for middleware executed before a
+    # response has been returned to a BitTorrent client.
+    prehooks:
+    #- name: jwt
+    #  options:
+    #    issuer: "https://issuer.com"
+    #    audience: "https://chihaya.issuer.com"
+    #    jwk_set_url: "https://issuer.com/keys"
+    #    jwk_set_update_interval: 5m
 
-  #- name: client approval
-  #  options:
-  #    whitelist:
-  #    - "OP1011"
-  #    blacklist:
-  #    - "OP1012"
+    #- name: client approval
+    #  options:
+    #    whitelist:
+    #    - "OP1011"
+    #    blacklist:
+    #    - "OP1012"
 
-  #- name: interval variation
-  #  options:
-  #    modify_response_probability: 0.2
-  #    max_increase_delta: 60
-  #    modify_min_interval: true
+    #- name: interval variation
+    #  options:
+    #    modify_response_probability: 0.2
+    #    max_increase_delta: 60
+    #    modify_min_interval: true
 
-  # This block defines configuration used for torrent approval, it requires to be given
-  # hashes for whitelist or for blacklist. Hashes are hexadecimal-encoaded.
-  #- name: torrent approval
-  #  options:
-  #    whitelist:
-  #    - "a1b2c3d4e5a1b2c3d4e5a1b2c3d4e5a1b2c3d4e5"
-  #    blacklist:
-  #    - "e1d2c3b4a5e1b2c3b4a5e1d2c3b4e5e1d2c3b4a5"
+    # This block defines configuration used for torrent approval, it requires to be given
+    # hashes for whitelist or for blacklist. Hashes are hexadecimal-encoaded.
+    #- name: torrent approval
+    #  options:
+    #    whitelist:
+    #    - "a1b2c3d4e5a1b2c3d4e5a1b2c3d4e5a1b2c3d4e5"
+    #    blacklist:
+    #    - "e1d2c3b4a5e1b2c3b4a5e1d2c3b4e5e1d2c3b4a5"
diff --git a/dist/helm/chihaya/Chart.yaml b/dist/helm/chihaya/Chart.yaml
index 1754677..64eade5 100644
--- a/dist/helm/chihaya/Chart.yaml
+++ b/dist/helm/chihaya/Chart.yaml
@@ -4,7 +4,7 @@ home: https://chihaya.io
 version: 0.1.0
 description: A Helm chart for running the Chihaya BitTorrent tracker on Kubernetes.
 sources:
-  - https://github.com/chihaya/chihaya
+    - https://github.com/chihaya/chihaya
 maintainers:
-  - name: Jimmy Zelinskie
-    email: jimmyzelinskie@gmail.com
+    -   name: Jimmy Zelinskie
+        email: jimmyzelinskie@gmail.com
diff --git a/dist/helm/chihaya/templates/configmap.yaml b/dist/helm/chihaya/templates/configmap.yaml
index 8b3ca87..c8c6bd5 100644
--- a/dist/helm/chihaya/templates/configmap.yaml
+++ b/dist/helm/chihaya/templates/configmap.yaml
@@ -1,9 +1,9 @@
 apiVersion: v1
 kind: ConfigMap
 metadata:
-  name: {{ template "fullname" . }}
-  labels:
-    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+    name: { { template "fullname" . } }
+    labels:
+        chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
 data:
-  config.yaml: |
-{{ toYaml .Values.config | indent 4 }}
+    config.yaml: |
+  { { toYaml .Values.config | indent 4 } }
diff --git a/dist/helm/chihaya/templates/deployment.yaml b/dist/helm/chihaya/templates/deployment.yaml
index 1b29a6d..36ba2c3 100644
--- a/dist/helm/chihaya/templates/deployment.yaml
+++ b/dist/helm/chihaya/templates/deployment.yaml
@@ -1,43 +1,43 @@
 apiVersion: extensions/v1beta1
 kind: Deployment
 metadata:
-  name: {{ template "fullname" . }}
-  labels:
-    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+    name: { { template "fullname" . } }
+    labels:
+        chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
 spec:
-  replicas: {{ .Values.replicaCount }}
-  template:
-    metadata:
-      labels:
-        app: {{ template "fullname" . }}
-    spec:
-      volumes:
-      - name: config
-        configMap:
-          name: {{ template "fullname" . }}
-      containers:
-      - name: {{ .Chart.Name }}
-        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
-        imagePullPolicy: {{ .Values.image.pullPolicy }}
-        args:
-        - "--config=/etc/chihaya/config.yaml"
-        - "--debug"
-        - "--json"
-        ports:
-        - name: bittorrent-http
-          containerPort: {{ $v := .Values.config.chihaya.http.addr | split ":" }}{{ $v._1 }}
-          protocol: TCP
-        - name: bittorrent-udp
-          containerPort: {{ $v := .Values.config.chihaya.udp.addr | split ":" }}{{ $v._1 }}
-          protocol: UDP
-        - name: metrics
-          containerPort: {{ $v := .Values.config.chihaya.metrics_addr | split ":" }}{{ $v._1 }}
-        livenessProbe:
-          httpGet:
-            path: /
-            port: {{ $v := .Values.config.chihaya.metrics_addr | split ":" }}{{ $v._1 }}
-        volumeMounts:
-        - name: config
-          mountPath: /etc/chihaya
-        resources:
-{{ toYaml .Values.resources | indent 10 }}
+    replicas: { { .Values.replicaCount } }
+    template:
+        metadata:
+            labels:
+                app: { { template "fullname" . } }
+        spec:
+            volumes:
+                -   name: config
+                    configMap:
+                        name: { { template "fullname" . } }
+            containers:
+                -   name: { { .Chart.Name } }
+                    image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
+                    imagePullPolicy: { { .Values.image.pullPolicy } }
+                    args:
+                        - "--config=/etc/chihaya/config.yaml"
+                        - "--debug"
+                        - "--json"
+                    ports:
+                        -   name: bittorrent-http
+                            containerPort: { { $v := .Values.config.chihaya.http.addr | split ":" } }{ { $v._1 } }
+                            protocol: TCP
+                        -   name: bittorrent-udp
+                            containerPort: { { $v := .Values.config.chihaya.udp.addr | split ":" } }{ { $v._1 } }
+                            protocol: UDP
+                        -   name: metrics
+                            containerPort: { { $v := .Values.config.chihaya.metrics_addr | split ":" } }{ { $v._1 } }
+                    livenessProbe:
+                        httpGet:
+                            path: /
+                            port: { { $v := .Values.config.chihaya.metrics_addr | split ":" } }{ { $v._1 } }
+                    volumeMounts:
+                        -   name: config
+                            mountPath: /etc/chihaya
+                    resources:
+  { { toYaml .Values.resources | indent 10 } }
diff --git a/dist/helm/chihaya/templates/service.yaml b/dist/helm/chihaya/templates/service.yaml
index 4e91a83..eecd81d 100644
--- a/dist/helm/chihaya/templates/service.yaml
+++ b/dist/helm/chihaya/templates/service.yaml
@@ -1,27 +1,27 @@
 apiVersion: v1
 kind: Service
 metadata:
-  name: {{ template "fullname" . }}
-  labels:
-    chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
-  annotations:
-    prometheus.io/scrape: "true"
-    prometheus.io/path: "/metrics"
-    prometheus.io/port: {{ $v := .Values.config.chihaya.metrics_addr | split ":" }}{{ $v._1 | quote }}
+    name: { { template "fullname" . } }
+    labels:
+        chart: "{{ .Chart.Name }}-{{ .Chart.Version }}"
+    annotations:
+        prometheus.io/scrape: "true"
+        prometheus.io/path: "/metrics"
+        prometheus.io/port: { { $v := .Values.config.chihaya.metrics_addr | split ":" } }{ { $v._1 | quote } }
 spec:
-  type: {{ .Values.service.type }}
-  ports:
-  - name: bittorrent-http
-    port: {{ $v := .Values.config.chihaya.http.addr | split ":" }}{{ $v._1 }}
-    targetPort: {{ $v := .Values.config.chihaya.http.addr | split ":" }}{{ $v._1 }}
-    protocol: TCP
-  - name: bittorrent-udp
-    port: {{ $v := .Values.config.chihaya.udp.addr | split ":" }}{{ $v._1 }}
-    targetPort: {{ $v := .Values.config.chihaya.udp.addr | split ":" }}{{ $v._1 }}
-    protocol: UDP
-  - name: metrics
-    port: {{ $v := .Values.config.chihaya.metrics_addr | split ":" }}{{ $v._1 }}
-    targetPort: {{ $v := .Values.config.chihaya.metrics_addr | split ":" }}{{ $v._1 }}
-    protocol: TCP
-  selector:
-    app: {{ template "fullname" . }}
+    type: { { .Values.service.type } }
+    ports:
+        -   name: bittorrent-http
+            port: { { $v := .Values.config.chihaya.http.addr | split ":" } }{ { $v._1 } }
+            targetPort: { { $v := .Values.config.chihaya.http.addr | split ":" } }{ { $v._1 } }
+            protocol: TCP
+        -   name: bittorrent-udp
+            port: { { $v := .Values.config.chihaya.udp.addr | split ":" } }{ { $v._1 } }
+            targetPort: { { $v := .Values.config.chihaya.udp.addr | split ":" } }{ { $v._1 } }
+            protocol: UDP
+        -   name: metrics
+            port: { { $v := .Values.config.chihaya.metrics_addr | split ":" } }{ { $v._1 } }
+            targetPort: { { $v := .Values.config.chihaya.metrics_addr | split ":" } }{ { $v._1 } }
+            protocol: TCP
+    selector:
+        app: { { template "fullname" . } }
diff --git a/dist/helm/chihaya/values.yaml b/dist/helm/chihaya/values.yaml
index 4fbf2bf..8a58f9c 100644
--- a/dist/helm/chihaya/values.yaml
+++ b/dist/helm/chihaya/values.yaml
@@ -1,162 +1,162 @@
 replicaCount: 1
 image:
-  repository: quay.io/jzelinskie/chihaya-git
-  tag: latest
-  pullPolicy: IfNotPresent
+    repository: quay.io/jzelinskie/chihaya-git
+    tag: latest
+    pullPolicy: IfNotPresent
 service:
-  name: chihaya
-  type: ClusterIP
+    name: chihaya
+    type: ClusterIP
 resources:
-  limits:
-    cpu: 100m
-    memory: 1Gi
+    limits:
+        cpu: 100m
+        memory: 1Gi
 config:
-  chihaya:
-    # The interval communicated with BitTorrent clients informing them how
-    # frequently they should announce in between client events.
-    announce_interval: 30m
+    chihaya:
+        # The interval communicated with BitTorrent clients informing them how
+        # frequently they should announce in between client events.
+        announce_interval: 30m
 
-    # The interval communicated with BitTorrent clients informing them of the
-    # minimal duration between announces.
-    min_announce_interval: 15m
+        # The interval communicated with BitTorrent clients informing them of the
+        # minimal duration between announces.
+        min_announce_interval: 15m
 
-    # The network interface that will bind to an HTTP endpoint that can be
-    # scraped by programs collecting metrics.
-    #
-    # /metrics serves metrics in the Prometheus format
-    # /debug/pprof/{cmdline,profile,symbol,trace} serves profiles in the pprof format
-    metrics_addr: "0.0.0.0:6880"
+        # The network interface that will bind to an HTTP endpoint that can be
+        # scraped by programs collecting metrics.
+        #
+        # /metrics serves metrics in the Prometheus format
+        # /debug/pprof/{cmdline,profile,symbol,trace} serves profiles in the pprof format
+        metrics_addr: "0.0.0.0:6880"
 
-    # The maximum number of peers returned in an announce.
-    max_numwant: 50
+        # The maximum number of peers returned in an announce.
+        max_numwant: 50
 
-    # The default number of peers returned in an announce.
-    default_numwant: 25
+        # The default number of peers returned in an announce.
+        default_numwant: 25
 
-    # The number of infohashes a single scrape can request before being truncated.
-    max_scrape_infohashes: 50
+        # The number of infohashes a single scrape can request before being truncated.
+        max_scrape_infohashes: 50
 
-    # This block defines configuration for the tracker's HTTP interface.
-    # If you do not wish to run this, delete this section.
-    http:
-      # The network interface that will bind to an HTTP server for serving
-      # BitTorrent traffic.
-      addr: "0.0.0.0:6969"
+        # This block defines configuration for the tracker's HTTP interface.
+        # If you do not wish to run this, delete this section.
+        http:
+            # The network interface that will bind to an HTTP server for serving
+            # BitTorrent traffic.
+            addr: "0.0.0.0:6969"
 
-      # The path to the required files to listen via HTTPS.
-      tls_cert_path: ""
-      tls_key_path: ""
+            # The path to the required files to listen via HTTPS.
+            tls_cert_path: ""
+            tls_key_path: ""
 
-      # The timeout durations for HTTP requests.
-      read_timeout: 5s
-      write_timeout: 5s
+            # The timeout durations for HTTP requests.
+            read_timeout: 5s
+            write_timeout: 5s
 
-      # Whether to time requests.
-      # Disabling this should increase performance/decrease load.
-      enable_request_timing: false
+            # Whether to time requests.
+            # Disabling this should increase performance/decrease load.
+            enable_request_timing: false
 
-      # When true, persistent connections will be allowed. Generally this is not
-      # useful for a public tracker, but helps performance in some cases (use of
-      # a reverse proxy, or when there are few clients issuing many requests).
-      enable_keepalive: false
-      idle_timeout: 30s
+            # When true, persistent connections will be allowed. Generally this is not
+            # useful for a public tracker, but helps performance in some cases (use of
+            # a reverse proxy, or when there are few clients issuing many requests).
+            enable_keepalive: false
+            idle_timeout: 30s
 
-      # Whether to listen on /announce.php and /scrape.php in addition to their
-      # non-.php counterparts.
-      # This is an option for compatibility with (very) old clients or otherwise
-      # outdated systems.
-      # This might be useful to retracker.local users, for more information see
-      # http://rutracker.wiki/Оптимизация_обмена_битторрент_траффиком_в_локальных_сетях
-      # and
-      # http://rutracker.wiki/Retracker.local
-      enable_legacy_php_urls: false
+            # Whether to listen on /announce.php and /scrape.php in addition to their
+            # non-.php counterparts.
+            # This is an option for compatibility with (very) old clients or otherwise
+            # outdated systems.
+            # This might be useful to retracker.local users, for more information see
+            # http://rutracker.wiki/Оптимизация_обмена_битторрент_траффиком_в_локальных_сетях
+            # and
+            # http://rutracker.wiki/Retracker.local
+            enable_legacy_php_urls: false
 
-      # When enabled, the IP address used to connect to the tracker will not
-      # override the value clients advertise as their IP address.
-      allow_ip_spoofing: false
+            # When enabled, the IP address used to connect to the tracker will not
+            # override the value clients advertise as their IP address.
+            allow_ip_spoofing: false
 
-      # The HTTP Header containing the IP address of the client.
-      # This is only necessary if using a reverse proxy.
-      real_ip_header: "x-real-ip"
+            # The HTTP Header containing the IP address of the client.
+            # This is only necessary if using a reverse proxy.
+            real_ip_header: "x-real-ip"
 
-      # The maximum number of peers returned for an individual request.
-      max_numwant: 100
+            # The maximum number of peers returned for an individual request.
+            max_numwant: 100
 
-      # The default number of peers returned for an individual request.
-      default_numwant: 50
+            # The default number of peers returned for an individual request.
+            default_numwant: 50
 
-      # The maximum number of infohashes that can be scraped in one request.
-      max_scrape_infohashes: 50
+            # The maximum number of infohashes that can be scraped in one request.
+            max_scrape_infohashes: 50
 
-    # This block defines configuration for the tracker's UDP interface.
-    # If you do not wish to run this, delete this section.
-    udp:
-      # The network interface that will bind to a UDP server for serving
-      # BitTorrent traffic.
-      addr: "0.0.0.0:6969"
+        # This block defines configuration for the tracker's UDP interface.
+        # If you do not wish to run this, delete this section.
+        udp:
+            # The network interface that will bind to a UDP server for serving
+            # BitTorrent traffic.
+            addr: "0.0.0.0:6969"
 
-      # The leeway for a timestamp on a connection ID.
-      max_clock_skew: 10s
+            # The leeway for a timestamp on a connection ID.
+            max_clock_skew: 10s
 
-      # The key used to encrypt connection IDs.
-      private_key: "paste a random string here that will be used to hmac connection IDs"
+            # The key used to encrypt connection IDs.
+            private_key: "paste a random string here that will be used to hmac connection IDs"
 
-      # Whether to time requests.
-      # Disabling this should increase performance/decrease load.
-      enable_request_timing: false
+            # Whether to time requests.
+            # Disabling this should increase performance/decrease load.
+            enable_request_timing: false
 
-      # When enabled, the IP address used to connect to the tracker will not
-      # override the value clients advertise as their IP address.
-      allow_ip_spoofing: false
+            # When enabled, the IP address used to connect to the tracker will not
+            # override the value clients advertise as their IP address.
+            allow_ip_spoofing: false
 
-      # The maximum number of peers returned for an individual request.
-      max_numwant: 100
+            # The maximum number of peers returned for an individual request.
+            max_numwant: 100
 
-      # The default number of peers returned for an individual request.
-      default_numwant: 50
+            # The default number of peers returned for an individual request.
+            default_numwant: 50
 
-      # The maximum number of infohashes that can be scraped in one request.
-      max_scrape_infohashes: 50
+            # The maximum number of infohashes that can be scraped in one request.
+            max_scrape_infohashes: 50
 
 
-    # This block defines configuration used for the storage of peer data.
-    storage:
-      name: memory
-      config:
-        # The frequency which stale peers are removed.
-        gc_interval: 3m
+        # This block defines configuration used for the storage of peer data.
+        storage:
+            name: memory
+            config:
+                # The frequency which stale peers are removed.
+                gc_interval: 3m
 
-        # The amount of time until a peer is considered stale.
-        # To avoid churn, keep this slightly larger than `announce_interval`
-        peer_lifetime: 31m
+                # The amount of time until a peer is considered stale.
+                # To avoid churn, keep this slightly larger than `announce_interval`
+                peer_lifetime: 31m
 
-        # The number of partitions data will be divided into in order to provide a
-        # higher degree of parallelism.
-        shard_count: 1024
+                # The number of partitions data will be divided into in order to provide a
+                # higher degree of parallelism.
+                shard_count: 1024
 
-        # The interval at which metrics about the number of infohashes and peers
-        # are collected and posted to Prometheus.
-        prometheus_reporting_interval: 1s
+                # The interval at which metrics about the number of infohashes and peers
+                # are collected and posted to Prometheus.
+                prometheus_reporting_interval: 1s
 
-    # This block defines configuration used for middleware executed before a
-    # response has been returned to a BitTorrent client.
-    prehooks:
-    #- name: jwt
-    #  options:
-    #    issuer: "https://issuer.com"
-    #    audience: "https://chihaya.issuer.com"
-    #    jwk_set_url: "https://issuer.com/keys"
-    #    jwk_set_update_interval: 5m
+        # This block defines configuration used for middleware executed before a
+        # response has been returned to a BitTorrent client.
+        prehooks:
+        #- name: jwt
+        #  options:
+        #    issuer: "https://issuer.com"
+        #    audience: "https://chihaya.issuer.com"
+        #    jwk_set_url: "https://issuer.com/keys"
+        #    jwk_set_update_interval: 5m
 
-    #- name: client approval
-    #  options:
-    #    whitelist:
-    #    - "OP1011"
-    #    blacklist:
-    #    - "OP1012"
+        #- name: client approval
+        #  options:
+        #    whitelist:
+        #    - "OP1011"
+        #    blacklist:
+        #    - "OP1012"
 
-    #- name: interval variation
-    #  options:
-    #    modify_response_probability: 0.2
-    #    max_increase_delta: 60
-    #    modify_min_interval: true
+        #- name: interval variation
+        #  options:
+        #    modify_response_probability: 0.2
+        #    max_increase_delta: 60
+        #    modify_min_interval: true
diff --git a/dist/prometheus/prometheus.yaml b/dist/prometheus/prometheus.yaml
index 818ef08..c2b0c2b 100644
--- a/dist/prometheus/prometheus.yaml
+++ b/dist/prometheus/prometheus.yaml
@@ -1,11 +1,11 @@
 global:
-  scrape_interval:     5s
-  evaluation_interval: 5s
+    scrape_interval: 5s
+    evaluation_interval: 5s
 
 # A scrape configuration containing exactly one endpoint to scrape:
 scrape_configs:
-  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
-  - job_name: 'local-chihaya' # you can name this however you want
-    scrape_interval: 5s # optionally override the global scrape_interval
-    static_configs:
-      - targets: ['localhost:6881'] # provide the address of chihaya's prometheus endpoint
+    # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
+    -   job_name: 'local-chihaya' # you can name this however you want
+        scrape_interval: 5s # optionally override the global scrape_interval
+        static_configs:
+            -   targets: [ 'localhost:6881' ] # provide the address of chihaya's prometheus endpoint
diff --git a/docs/architecture.md b/docs/architecture.md
index dad5b8e..9a6f57a 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -2,14 +2,14 @@
 
 ### Overview
 
-BitTorrent clients send Announce and Scrape requests to a _Frontend_.
-Frontends parse requests and write responses for the particular protocol they implement.
-The _TrackerLogic_ interface is used to generate responses for requests and optionally perform a task after responding to a client.
-A configurable chain of _PreHook_ and _PostHook_ middleware is used to construct an instance of TrackerLogic.
-PreHooks are middleware that are executed before the response has been written.
-After all PreHooks have executed, any missing response fields that are required are filled by reading out of the configured implementation of the _Storage_ interface.
-PostHooks are asynchronous tasks that occur after a response has been delivered to the client.
-Because they are unnecessary to for generating a response, updates to the Storage for a particular request are done asynchronously in a PostHook.
+BitTorrent clients send Announce and Scrape requests to a _Frontend_. Frontends parse requests and write responses for
+the particular protocol they implement. The _TrackerLogic_ interface is used to generate responses for requests and
+optionally perform a task after responding to a client. A configurable chain of _PreHook_ and _PostHook_ middleware is
+used to construct an instance of TrackerLogic. PreHooks are middleware that are executed before the response has been
+written. After all PreHooks have executed, any missing response fields that are required are filled by reading out of
+the configured implementation of the _Storage_ interface. PostHooks are asynchronous tasks that occur after a response
+has been delivered to the client. Because they are unnecessary to for generating a response, updates to the Storage for
+a particular request are done asynchronously in a PostHook.
 
 ### Diagram
 
diff --git a/docs/frontend.md b/docs/frontend.md
index 5826eab..1816ac7 100644
--- a/docs/frontend.md
+++ b/docs/frontend.md
@@ -1,15 +1,15 @@
 # Frontends
 
-A _Frontend_ is a component of Chihaya that serves a BitTorrent tracker on one protocol.
-The frontend accepts, parses and sanitizes requests, passes them to the _Logic_ and writes responses to _Clients_.
+A _Frontend_ is a component of Chihaya that serves a BitTorrent tracker on one protocol. The frontend accepts, parses
+and sanitizes requests, passes them to the _Logic_ and writes responses to _Clients_.
 
-This documentation first gives a high-level overview of Frontends and later goes into implementation specifics.
-Users of Chihaya are expected to just read the first part - developers should read both.
+This documentation first gives a high-level overview of Frontends and later goes into implementation specifics. Users of
+Chihaya are expected to just read the first part - developers should read both.
 
 ## Functionality
 
-A Frontend serves one protocol, for example HTTP ([BEP 3]) or UDP ([BEP 15]).
-It listens for requests and usually answers each of them with one response, a basic overview of the control flow is:
+A Frontend serves one protocol, for example HTTP ([BEP 3]) or UDP ([BEP 15]). It listens for requests and usually
+answers each of them with one response, a basic overview of the control flow is:
 
 1. Read the request.
 2. Parse the request.
@@ -19,10 +19,9 @@ It listens for requests and usually answers each of them with one response, a ba
 
 ## Available Frontends
 
-Chihaya ships with frontends for HTTP(S) and UDP.
-The HTTP frontend uses Go's `http` package.
-The UDP frontend implements both [old-opentracker-style] IPv6 and the IPv6 support specified in [BEP 15].
-The advantage of the old opentracker style is that it contains a usable IPv6 `ip` field, to enable IP overrides in announces.
+Chihaya ships with frontends for HTTP(S) and UDP. The HTTP frontend uses Go's `http` package. The UDP frontend
+implements both [old-opentracker-style] IPv6 and the IPv6 support specified in [BEP 15]. The advantage of the old
+opentracker style is that it contains a usable IPv6 `ip` field, to enable IP overrides in announces.
 
 ## Implementing a Frontend
 
@@ -30,8 +29,7 @@ This part is intended for developers.
 
 ### Implementation Specifics
 
-A frontend should serve only one protocol.
-It may serve that protocol on multiple transports or networks, if applicable.
+A frontend should serve only one protocol. It may serve that protocol on multiple transports or networks, if applicable.
 An example of that is the `http` Frontend, operating both on HTTP and HTTPS.
 
 The typical control flow of handling announces, in more detail, is:
@@ -44,66 +42,69 @@ The typical control flow of handling announces, in more detail, is:
 6. Send the response to the Client.
 7. Pass the request and response to the `TrackerLogic`'s `AfterAnnounce` or `AfterScrape` method.
 8. Finish, accept next request.
-9. For invalid requests or errors during processing: Send an error response to the client. 
-    This step may be skipped for suspected denial-of-service attacks.
-    The error response may contain information about the cause of the error.
-    Only errors where the Client is at fault should be explained, internal server errors should be returned without explanation. 
-    Then finish, and accept the next request.
+9. For invalid requests or errors during processing: Send an error response to the client. This step may be skipped for
+   suspected denial-of-service attacks. The error response may contain information about the cause of the error. Only
+   errors where the Client is at fault should be explained, internal server errors should be returned without
+   explanation. Then finish, and accept the next request.
 
 #### Configuration
 
-The frontend must be configurable using a single, exported struct.
-The struct must have YAML annotations.
-The struct must implement `log.Fielder` to be logged on startup.
+The frontend must be configurable using a single, exported struct. The struct must have YAML annotations. The struct
+must implement `log.Fielder` to be logged on startup.
 
 #### Metrics
 
-Frontends may provide runtime metrics, such as the number of requests or their duration.
-Metrics must be reported using [Prometheus].
+Frontends may provide runtime metrics, such as the number of requests or their duration. Metrics must be reported
+using [Prometheus].
 
 A frontend should provide at least the following metrics:
-- The number of valid and invalid requests handled
-- The average time it takes to handle a single request.
-    This request timing should be made optional using a config entry.
 
-Requests should be separated by type, i.e. Scrapes, Announces, and other protocol-specific requests.
-If the frontend serves multiple transports or networks, metrics for them should be separable.
+- The number of valid and invalid requests handled
+- The average time it takes to handle a single request. This request timing should be made optional using a config
+  entry.
+
+Requests should be separated by type, i.e. Scrapes, Announces, and other protocol-specific requests. If the frontend
+serves multiple transports or networks, metrics for them should be separable.
 
 It is recommended to publish one Prometheus `HistogramVec` with:
+
 - A name like `chihaya_PROTOCOL_response_duration_milliseconds`
 - A value holding the duration in milliseconds of the reported request
 - Labels for:
-    - `action` (= `announce`, `scrape`, ...)
-    - `address_family` (= `Unknown`, `IPv4`, `IPv6`, ...), if applicable
-     - `error` (= A textual representation of the error encountered during processing.)
-    Because `error` is expected to hold the textual representation of any error that occurred during the request, great care must be taken to ensure all error messages are static.
-    `error` must not contain any information directly taken from the request, e.g. the value of an invalid parameter.
-    This would cause this dimension of prometheus to explode, which slows down prometheus clients and reporters.
+	- `action` (= `announce`, `scrape`, ...)
+	- `address_family` (= `Unknown`, `IPv4`, `IPv6`, ...), if applicable
+	- `error` (= A textual representation of the error encountered during processing.)
+	  Because `error` is expected to hold the textual representation of any error that occurred during the request,
+	  great care must be taken to ensure all error messages are static.
+	  `error` must not contain any information directly taken from the request, e.g. the value of an invalid parameter.
+	  This would cause this dimension of prometheus to explode, which slows down prometheus clients and reporters.
 
 #### Error Handling
 
-Frontends should return `bittorrent.ClientError`s to the Client.
-Frontends must not return errors that are not a `bittorrent.ClientError` to the Client.
-A message like `internal server error` should be used instead.
+Frontends should return `bittorrent.ClientError`s to the Client. Frontends must not return errors that are not
+a `bittorrent.ClientError` to the Client. A message like `internal server error` should be used instead.
 
 #### Request Sanitization
 
 The `TrackerLogic` expects sanitized requests in order to function properly.
 
-The `bittorrent` package provides the `SanitizeAnnounce` and `SanitizeScrape` functions to sanitize Announces and Scrapes, respectively.
-This is the minimal required sanitization, every `AnnounceRequest` and `ScrapeRequest` must be sanitized this way.
+The `bittorrent` package provides the `SanitizeAnnounce` and `SanitizeScrape` functions to sanitize Announces and
+Scrapes, respectively. This is the minimal required sanitization, every `AnnounceRequest` and `ScrapeRequest` must be
+sanitized this way.
 
-Note that the `AnnounceRequest` struct contains booleans of the form `XProvided`, where `X` denotes an optional parameter of the BitTorrent protocol.
-These should be set according to the values received by the Client.
+Note that the `AnnounceRequest` struct contains booleans of the form `XProvided`, where `X` denotes an optional
+parameter of the BitTorrent protocol. These should be set according to the values received by the Client.
 
 #### Contexts
 
-All methods of the `TrackerLogic` interface expect a `context.Context` as a parameter.
-After a request is handled by `HandleAnnounce` without errors, the populated context returned must be used to call `AfterAnnounce`.
-The same applies to Scrapes.
-This way, a PreHook can communicate with a PostHook by setting a context value.
+All methods of the `TrackerLogic` interface expect a `context.Context` as a parameter. After a request is handled
+by `HandleAnnounce` without errors, the populated context returned must be used to call `AfterAnnounce`. The same
+applies to Scrapes. This way, a PreHook can communicate with a PostHook by setting a context value.
 
 [BEP 3]: http://bittorrent.org/beps/bep_0003.html
+
 [BEP 15]: http://bittorrent.org/beps/bep_0015.html
+
 [Prometheus]: https://prometheus.io/
+
 [old-opentracker-style]: https://web.archive.org/web/20170503181830/http://opentracker.blog.h3q.com/2007/12/28/the-ipv6-situation/
\ No newline at end of file
diff --git a/docs/middleware/interval_variation.md b/docs/middleware/interval_variation.md
index 8478ee2..12684c5 100644
--- a/docs/middleware/interval_variation.md
+++ b/docs/middleware/interval_variation.md
@@ -4,21 +4,23 @@ This package provides the announce middleware `interval variation` which randomi
 
 ## Functionality
 
-This middleware chooses random announces and modifies the `interval` and `min_interval` fields.
-A random number of seconds are added to the `interval` field and, if desired, also to the `min_interval` field.
+This middleware chooses random announces and modifies the `interval` and `min_interval` fields. A random number of
+seconds are added to the `interval` field and, if desired, also to the `min_interval` field.
 
-Note that if a response is picked for modification and `min_interval` should be changed as well, both `interval` and `min_interval` are modified by the same amount.
+Note that if a response is picked for modification and `min_interval` should be changed as well, both `interval`
+and `min_interval` are modified by the same amount.
 
 ## Use Case
 
-Use this middleware to avoid recurring load spikes on the tracker.
-By randomizing the announce interval, load spikes will flatten out after a few announce cycles.
+Use this middleware to avoid recurring load spikes on the tracker. By randomizing the announce interval, load spikes
+will flatten out after a few announce cycles.
 
 ## Configuration
 
 This middleware provides the following parameters for configuration:
 
-- `modify_response_probability` (float, >0, <= 1) indicates the probability by which a response will be chosen to have its announce intervals modified.
+- `modify_response_probability` (float, >0, <= 1) indicates the probability by which a response will be chosen to have
+  its announce intervals modified.
 - `max_increase_delta` (int, >0) sets an upper boundary (inclusive) for the amount of seconds added.
 - `modify_min_interval` (boolean) whether to modify the `min_interval` field as well.
 
diff --git a/docs/storage/redis.md b/docs/storage/redis.md
index da3b3fb..361ef80 100644
--- a/docs/storage/redis.md
+++ b/docs/storage/redis.md
@@ -1,14 +1,11 @@
 # Redis Storage
 
-This storage implementation separates Chihaya from its storage service.
-Chihaya achieves HA by storing all peer data in Redis.
-Multiple instances of Chihaya can use the same redis instance concurrently.
-The storage service can get HA by clustering.
-If one instance of Chihaya goes down, peer data will still be available in Redis.
+This storage implementation separates Chihaya from its storage service. Chihaya achieves HA by storing all peer data in
+Redis. Multiple instances of Chihaya can use the same redis instance concurrently. The storage service can get HA by
+clustering. If one instance of Chihaya goes down, peer data will still be available in Redis.
 
-The HA of storage service is not considered here.
-In case Redis runs as a single node, peer data will be unavailable if the node is down.
-You should consider setting up a Redis cluster for Chihaya in production.
+The HA of storage service is not considered here. In case Redis runs as a single node, peer data will be unavailable if
+the node is down. You should consider setting up a Redis cluster for Chihaya in production.
 
 This storage implementation is currently orders of magnitude slower than the in-memory implementation.
 
@@ -52,10 +49,10 @@ chihaya:
 
 ## Implementation
 
-Seeders and Leechers for a particular InfoHash are stored within a redis hash.
-The InfoHash is used as key, _peer keys_ are the fields, last modified times are values.
-Peer keys are derived from peers and contain Peer ID, IP, and Port.
-All the InfoHashes (swarms) are also stored in a redis hash, with IP family as the key, infohash as field, and last modified time as value.
+Seeders and Leechers for a particular InfoHash are stored within a redis hash. The InfoHash is used as key, _peer keys_
+are the fields, last modified times are values. Peer keys are derived from peers and contain Peer ID, IP, and Port. All
+the InfoHashes (swarms) are also stored in a redis hash, with IP family as the key, infohash as field, and last modified
+time as value.
 
 Here is an example:
 
@@ -73,9 +70,8 @@ Here is an example:
   - <peer 3 key>: <modification time>
 ```
 
-
-In this case, prometheus would record two swarms, three seeders, and one leecher.
-These three keys per address family are used to record the count of swarms, seeders, and leechers.
+In this case, prometheus would record two swarms, three seeders, and one leecher. These three keys per address family
+are used to record the count of swarms, seeders, and leechers.
 
 ```
 - IPv4_infohash_count: 2
diff --git a/middleware/torrentapproval/container/directory/directory.go b/middleware/torrentapproval/container/directory/directory.go
index 4eb8dd0..12e3a3d 100644
--- a/middleware/torrentapproval/container/directory/directory.go
+++ b/middleware/torrentapproval/container/directory/directory.go
@@ -58,7 +58,7 @@ func build(confBytes []byte, st storage.Storage) (container.Container, error) {
 				data := make([]storage.Pair, 1, 2)
 				data[0] = storage.Pair{Left: event.InfoHash[:], Right: list.DUMMY}
 				if v2ih, err := v2InfoHash(event.TorrentFilePath); err == nil {
-					data = append(data, storage.Pair{Left: v2ih, Right: list.DUMMY})
+					data = append(data, storage.Pair{Left: v2ih.RawString(), Right: list.DUMMY})
 				} else {
 					log.Err(err)
 				}
@@ -67,7 +67,7 @@ func build(confBytes []byte, st storage.Storage) (container.Container, error) {
 				data := make([]interface{}, 1, 2)
 				data[0] = event.InfoHash[:]
 				if v2ih, err := v2InfoHash(event.TorrentFilePath); err == nil {
-					data = append(data, v2ih)
+					data = append(data, v2ih.RawString())
 				} else {
 					log.Err(err)
 				}
diff --git a/middleware/torrentapproval/container/list/list.go b/middleware/torrentapproval/container/list/list.go
index 3adb372..6fe5e27 100644
--- a/middleware/torrentapproval/container/list/list.go
+++ b/middleware/torrentapproval/container/list/list.go
@@ -3,7 +3,6 @@
 package list
 
 import (
-	"encoding/hex"
 	"fmt"
 	"github.com/chihaya/chihaya/bittorrent"
 	"github.com/chihaya/chihaya/middleware/torrentapproval/container"
@@ -45,15 +44,14 @@ func build(confBytes []byte, st storage.Storage) (container.Container, error) {
 	if len(c.HashList) > 0 {
 		init := make([]storage.Pair, 0, len(c.HashList))
 		for _, hashString := range c.HashList {
-			hashBytes, err := hex.DecodeString(hashString)
-			if err != nil {
-				return nil, fmt.Errorf("whitelist : invalid hash %s, %v", hashString, err)
-			}
-			ih, err := bittorrent.NewInfoHash(hashBytes)
+			ih, err := bittorrent.NewInfoHash(hashString)
 			if err != nil {
 				return nil, fmt.Errorf("whitelist : %s : %v", hashString, err)
 			}
-			init = append(init, storage.Pair{Left: ih, Right: DUMMY})
+			init = append(init, storage.Pair{Left: ih.RawString(), Right: DUMMY})
+			if len(ih) == bittorrent.InfoHashV2Len {
+				init = append(init, storage.Pair{Left: ih.TruncateV1().RawString(), Right: DUMMY})
+			}
 		}
 		l.Storage.BulkPut(l.StorageCtx, init...)
 	}
@@ -67,6 +65,9 @@ type List struct {
 }
 
 func (l *List) Approved(hash bittorrent.InfoHash) bool {
-	b := l.Storage.Contains(l.StorageCtx, hash)
+	b := l.Storage.Contains(l.StorageCtx, hash.RawString())
+	if len(hash) == bittorrent.InfoHashV2Len {
+		b = b || l.Storage.Contains(l.StorageCtx, hash.TruncateV1().RawString())
+	}
 	return b != l.Invert
 }
diff --git a/middleware/torrentapproval/torrentapproval_test.go b/middleware/torrentapproval/torrentapproval_test.go
index 4395e21..3127544 100644
--- a/middleware/torrentapproval/torrentapproval_test.go
+++ b/middleware/torrentapproval/torrentapproval_test.go
@@ -2,7 +2,6 @@ package torrentapproval
 
 import (
 	"context"
-	"encoding/hex"
 	"fmt"
 	"github.com/chihaya/chihaya/middleware"
 	"github.com/chihaya/chihaya/storage/memory"
@@ -83,10 +82,7 @@ func TestHandleAnnounce(t *testing.T) {
 			req := &bittorrent.AnnounceRequest{}
 			resp := &bittorrent.AnnounceResponse{}
 
-			hashbytes, err := hex.DecodeString(tt.ih)
-			require.Nil(t, err)
-
-			hashinfo, err := bittorrent.NewInfoHash(hashbytes)
+			hashinfo, err := bittorrent.NewInfoHash(tt.ih)
 			require.Nil(t, err)
 
 			req.InfoHash = hashinfo
diff --git a/storage/memory/storage.go b/storage/memory/storage.go
index 7cd8e35..1d72b56 100644
--- a/storage/memory/storage.go
+++ b/storage/memory/storage.go
@@ -534,7 +534,7 @@ func (ps *store) Delete(ctx string, keys ...interface{}) {
 	if len(keys) > 0 {
 		if m, found := ps.contexts.Load(ctx); found {
 			m := m.(*sync.Map)
-			for k := range keys {
+			for _, k := range keys {
 				m.Delete(asKey(k))
 			}
 		}
diff --git a/storage/memory/storage_test.go b/storage/memory/storage_test.go
index 4e35131..880ffdb 100644
--- a/storage/memory/storage_test.go
+++ b/storage/memory/storage_test.go
@@ -1,6 +1,7 @@
 package memory
 
 import (
+	"github.com/chihaya/chihaya/storage/test"
 	"testing"
 	"time"
 
@@ -20,32 +21,6 @@ func createNew() s.Storage {
 	return ps
 }
 
-func TestPeerStore(t *testing.T) { s.TestPeerStore(t, createNew()) }
+func TestStorage(t *testing.T) { test.RunTests(t, createNew()) }
 
-func BenchmarkNop(b *testing.B)                        { s.Nop(b, createNew()) }
-func BenchmarkPut(b *testing.B)                        { s.Put(b, createNew()) }
-func BenchmarkPut1k(b *testing.B)                      { s.Put1k(b, createNew()) }
-func BenchmarkPut1kInfohash(b *testing.B)              { s.Put1kInfohash(b, createNew()) }
-func BenchmarkPut1kInfohash1k(b *testing.B)            { s.Put1kInfohash1k(b, createNew()) }
-func BenchmarkPutDelete(b *testing.B)                  { s.PutDelete(b, createNew()) }
-func BenchmarkPutDelete1k(b *testing.B)                { s.PutDelete1k(b, createNew()) }
-func BenchmarkPutDelete1kInfohash(b *testing.B)        { s.PutDelete1kInfohash(b, createNew()) }
-func BenchmarkPutDelete1kInfohash1k(b *testing.B)      { s.PutDelete1kInfohash1k(b, createNew()) }
-func BenchmarkDeleteNonexist(b *testing.B)             { s.DeleteNonexist(b, createNew()) }
-func BenchmarkDeleteNonexist1k(b *testing.B)           { s.DeleteNonexist1k(b, createNew()) }
-func BenchmarkDeleteNonexist1kInfohash(b *testing.B)   { s.DeleteNonexist1kInfohash(b, createNew()) }
-func BenchmarkDeleteNonexist1kInfohash1k(b *testing.B) { s.DeleteNonexist1kInfohash1k(b, createNew()) }
-func BenchmarkPutGradDelete(b *testing.B)              { s.PutGradDelete(b, createNew()) }
-func BenchmarkPutGradDelete1k(b *testing.B)            { s.PutGradDelete1k(b, createNew()) }
-func BenchmarkPutGradDelete1kInfohash(b *testing.B)    { s.PutGradDelete1kInfohash(b, createNew()) }
-func BenchmarkPutGradDelete1kInfohash1k(b *testing.B)  { s.PutGradDelete1kInfohash1k(b, createNew()) }
-func BenchmarkGradNonexist(b *testing.B)               { s.GradNonexist(b, createNew()) }
-func BenchmarkGradNonexist1k(b *testing.B)             { s.GradNonexist1k(b, createNew()) }
-func BenchmarkGradNonexist1kInfohash(b *testing.B)     { s.GradNonexist1kInfohash(b, createNew()) }
-func BenchmarkGradNonexist1kInfohash1k(b *testing.B)   { s.GradNonexist1kInfohash1k(b, createNew()) }
-func BenchmarkAnnounceLeecher(b *testing.B)            { s.AnnounceLeecher(b, createNew()) }
-func BenchmarkAnnounceLeecher1kInfohash(b *testing.B)  { s.AnnounceLeecher1kInfohash(b, createNew()) }
-func BenchmarkAnnounceSeeder(b *testing.B)             { s.AnnounceSeeder(b, createNew()) }
-func BenchmarkAnnounceSeeder1kInfohash(b *testing.B)   { s.AnnounceSeeder1kInfohash(b, createNew()) }
-func BenchmarkScrapeSwarm(b *testing.B)                { s.ScrapeSwarm(b, createNew()) }
-func BenchmarkScrapeSwarm1kInfohash(b *testing.B)      { s.ScrapeSwarm1kInfohash(b, createNew()) }
+func BenchmarkStorage(b *testing.B) { test.RunBenchmarks(b, createNew) }
diff --git a/storage/redis/storage.go b/storage/redis/storage.go
index e8330b5..d149d33 100644
--- a/storage/redis/storage.go
+++ b/storage/redis/storage.go
@@ -24,8 +24,8 @@
 package redis
 
 import (
-	"fmt"
 	"strconv"
+	"strings"
 	"sync"
 	"time"
 
@@ -609,22 +609,30 @@ func (ps *store) ScrapeSwarm(ih bittorrent.InfoHash, af bittorrent.AddressFamily
 func (ps *store) Put(ctx string, key, value interface{}) {
 	conn := ps.getConnection()
 	defer closeConnection(conn)
-	_ = conn.Send("HSET", ctx, key, value)
+	_, err := conn.Do("HSET", ctx, key, value)
+	if err != nil {
+		panic(err)
+	}
 }
 
 func (ps *store) Contains(ctx string, key interface{}) bool {
 	conn := ps.getConnection()
 	defer closeConnection(conn)
-	exist, _ := redis.Bool(conn.Do("HEXISTS", ctx, key))
+	exist, err := redis.Bool(conn.Do("HEXISTS", ctx, key))
+	if err != nil {
+		panic(err)
+	}
 	return exist
 }
 
+const argNumErrorMsg = "ERR wrong number of arguments"
+
 func (ps *store) BulkPut(ctx string, pairs ...storage.Pair) {
 	switch l := len(pairs); l {
 	case 0:
 		break
 	case 1:
-		ps.Put(ctx, fmt.Sprint(pairs[0].Left), pairs[0].Right)
+		ps.Put(ctx, pairs[0].Left, pairs[0].Right)
 	default:
 		conn := ps.getConnection()
 		defer closeConnection(conn)
@@ -633,14 +641,29 @@ func (ps *store) BulkPut(ctx string, pairs ...storage.Pair) {
 		for _, p := range pairs {
 			args = append(args, p.Left, p.Right)
 		}
-		_ = conn.Send("HSET", args...)
+		_, err := conn.Do("HSET", args...)
+		if err != nil {
+			if strings.Contains(err.Error(), argNumErrorMsg) {
+				log.Warn("This REDIS version/implementation does not support variadic arguments for HSET")
+				for _, p := range pairs {
+					if _, err := conn.Do("HSET", ctx, p.Left, p.Right); err != nil {
+						panic(err)
+					}
+				}
+			} else {
+				panic(err)
+			}
+		}
 	}
 }
 
 func (ps *store) Load(ctx string, key interface{}) interface{} {
 	conn := ps.getConnection()
 	defer closeConnection(conn)
-	v, _ := conn.Do("HGET", ctx, key)
+	v, err := conn.Do("HGET", ctx, key)
+	if err != nil {
+		panic(err)
+	}
 	return v
 }
 
@@ -651,14 +674,29 @@ func (ps *store) Delete(ctx string, keys ...interface{}) {
 	case 1:
 		conn := ps.getConnection()
 		defer closeConnection(conn)
-		_ = conn.Send("HDEL", ctx, keys[0])
+		_, err := conn.Do("HDEL", ctx, keys[0])
+		if err != nil {
+			panic(err)
+		}
 	default:
 		conn := ps.getConnection()
 		defer closeConnection(conn)
 		args := make([]interface{}, 1, l+1)
 		args[0] = ctx
 		args = append(args, keys...)
-		_ = conn.Send("HDEL", args...)
+		_, err := conn.Do("HDEL", args...)
+		if err != nil {
+			if strings.Contains(err.Error(), argNumErrorMsg) {
+				log.Warn("This REDIS version/implementation does not support variadic arguments for HDEL")
+				for _, k := range keys {
+					if _, err := conn.Do("HDEL", ctx, k); err != nil {
+						panic(err)
+					}
+				}
+			} else {
+				panic(err)
+			}
+		}
 	}
 }
 
diff --git a/storage/redis/storage_test.go b/storage/redis/storage_test.go
index 1edf32a..7da72cc 100644
--- a/storage/redis/storage_test.go
+++ b/storage/redis/storage_test.go
@@ -6,8 +6,8 @@ import (
 	"time"
 
 	"github.com/alicebob/miniredis"
-
 	s "github.com/chihaya/chihaya/storage"
+	"github.com/chihaya/chihaya/storage/test"
 )
 
 func createNew() s.Storage {
@@ -30,32 +30,6 @@ func createNew() s.Storage {
 	return ps
 }
 
-func TestPeerStore(t *testing.T) { s.TestPeerStore(t, createNew()) }
+func TestStorage(t *testing.T) { test.RunTests(t, createNew()) }
 
-func BenchmarkNop(b *testing.B)                        { s.Nop(b, createNew()) }
-func BenchmarkPut(b *testing.B)                        { s.Put(b, createNew()) }
-func BenchmarkPut1k(b *testing.B)                      { s.Put1k(b, createNew()) }
-func BenchmarkPut1kInfohash(b *testing.B)              { s.Put1kInfohash(b, createNew()) }
-func BenchmarkPut1kInfohash1k(b *testing.B)            { s.Put1kInfohash1k(b, createNew()) }
-func BenchmarkPutDelete(b *testing.B)                  { s.PutDelete(b, createNew()) }
-func BenchmarkPutDelete1k(b *testing.B)                { s.PutDelete1k(b, createNew()) }
-func BenchmarkPutDelete1kInfohash(b *testing.B)        { s.PutDelete1kInfohash(b, createNew()) }
-func BenchmarkPutDelete1kInfohash1k(b *testing.B)      { s.PutDelete1kInfohash1k(b, createNew()) }
-func BenchmarkDeleteNonexist(b *testing.B)             { s.DeleteNonexist(b, createNew()) }
-func BenchmarkDeleteNonexist1k(b *testing.B)           { s.DeleteNonexist1k(b, createNew()) }
-func BenchmarkDeleteNonexist1kInfohash(b *testing.B)   { s.DeleteNonexist1kInfohash(b, createNew()) }
-func BenchmarkDeleteNonexist1kInfohash1k(b *testing.B) { s.DeleteNonexist1kInfohash1k(b, createNew()) }
-func BenchmarkPutGradDelete(b *testing.B)              { s.PutGradDelete(b, createNew()) }
-func BenchmarkPutGradDelete1k(b *testing.B)            { s.PutGradDelete1k(b, createNew()) }
-func BenchmarkPutGradDelete1kInfohash(b *testing.B)    { s.PutGradDelete1kInfohash(b, createNew()) }
-func BenchmarkPutGradDelete1kInfohash1k(b *testing.B)  { s.PutGradDelete1kInfohash1k(b, createNew()) }
-func BenchmarkGradNonexist(b *testing.B)               { s.GradNonexist(b, createNew()) }
-func BenchmarkGradNonexist1k(b *testing.B)             { s.GradNonexist1k(b, createNew()) }
-func BenchmarkGradNonexist1kInfohash(b *testing.B)     { s.GradNonexist1kInfohash(b, createNew()) }
-func BenchmarkGradNonexist1kInfohash1k(b *testing.B)   { s.GradNonexist1kInfohash1k(b, createNew()) }
-func BenchmarkAnnounceLeecher(b *testing.B)            { s.AnnounceLeecher(b, createNew()) }
-func BenchmarkAnnounceLeecher1kInfohash(b *testing.B)  { s.AnnounceLeecher1kInfohash(b, createNew()) }
-func BenchmarkAnnounceSeeder(b *testing.B)             { s.AnnounceSeeder(b, createNew()) }
-func BenchmarkAnnounceSeeder1kInfohash(b *testing.B)   { s.AnnounceSeeder1kInfohash(b, createNew()) }
-func BenchmarkScrapeSwarm(b *testing.B)                { s.ScrapeSwarm(b, createNew()) }
-func BenchmarkScrapeSwarm1kInfohash(b *testing.B)      { s.ScrapeSwarm1kInfohash(b, createNew()) }
+func BenchmarkStorage(b *testing.B) { test.RunBenchmarks(b, createNew) }
diff --git a/storage/storage_test.go b/storage/storage_test.go
deleted file mode 100644
index acd6f8f..0000000
--- a/storage/storage_test.go
+++ /dev/null
@@ -1,169 +0,0 @@
-package storage
-
-import (
-	"net"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/chihaya/chihaya/bittorrent"
-)
-
-// PeerEqualityFunc is the boolean function to use to check two Peers for
-// equality.
-// Depending on the implementation of the Storage, this can be changed to
-// use (Peer).EqualEndpoint instead.
-var PeerEqualityFunc = func(p1, p2 bittorrent.Peer) bool { return p1.Equal(p2) }
-
-// TestPeerStore tests a Storage implementation against the interface.
-func TestPeerStore(t *testing.T, p Storage) {
-	ih0, _ := bittorrent.NewInfoHash([]byte("00000000000000000001"))
-	ih1, _ := bittorrent.NewInfoHash([]byte("00000000000000000002"))
-	id0, _ := bittorrent.NewPeerID([]byte("00000000000000000001"))
-	id1, _ := bittorrent.NewPeerID([]byte("00000000000000000001"))
-	id2, _ := bittorrent.NewPeerID([]byte("00000000000000000001"))
-	id3, _ := bittorrent.NewPeerID([]byte("00000000000000000001"))
-	testData := []struct {
-		ih   bittorrent.InfoHash
-		peer bittorrent.Peer
-	}{
-		{
-			ih0,
-			bittorrent.Peer{ID: id0, Port: 1, IP: bittorrent.IP{IP: net.ParseIP("1.1.1.1").To4(), AddressFamily: bittorrent.IPv4}},
-		},
-		{
-			ih1,
-			bittorrent.Peer{ID: id1, Port: 2, IP: bittorrent.IP{IP: net.ParseIP("abab::0001"), AddressFamily: bittorrent.IPv6}},
-		},
-	}
-
-	v4Peer := bittorrent.Peer{ID: id2, IP: bittorrent.IP{IP: net.ParseIP("99.99.99.99").To4(), AddressFamily: bittorrent.IPv4}, Port: 9994}
-	v6Peer := bittorrent.Peer{ID: id3, IP: bittorrent.IP{IP: net.ParseIP("fc00::0001"), AddressFamily: bittorrent.IPv6}, Port: 9996}
-
-	for _, c := range testData {
-		peer := v4Peer
-		if c.peer.IP.AddressFamily == bittorrent.IPv6 {
-			peer = v6Peer
-		}
-
-		// Test ErrDNE for non-existent swarms.
-		err := p.DeleteLeecher(c.ih, c.peer)
-		require.Equal(t, ErrResourceDoesNotExist, err)
-
-		err = p.DeleteSeeder(c.ih, c.peer)
-		require.Equal(t, ErrResourceDoesNotExist, err)
-
-		_, err = p.AnnouncePeers(c.ih, false, 50, peer)
-		require.Equal(t, ErrResourceDoesNotExist, err)
-
-		// Test empty scrape response for non-existent swarms.
-		scrape := p.ScrapeSwarm(c.ih, c.peer.IP.AddressFamily)
-		require.Equal(t, uint32(0), scrape.Complete)
-		require.Equal(t, uint32(0), scrape.Incomplete)
-		require.Equal(t, uint32(0), scrape.Snatches)
-
-		// Insert dummy Peer to keep swarm active
-		// Has the same address family as c.peer
-		err = p.PutLeecher(c.ih, peer)
-		require.Nil(t, err)
-
-		// Test ErrDNE for non-existent seeder.
-		err = p.DeleteSeeder(c.ih, peer)
-		require.Equal(t, ErrResourceDoesNotExist, err)
-
-		// Test PutLeecher -> Announce -> DeleteLeecher -> Announce
-
-		err = p.PutLeecher(c.ih, c.peer)
-		require.Nil(t, err)
-
-		peers, err := p.AnnouncePeers(c.ih, true, 50, peer)
-		require.Nil(t, err)
-		require.True(t, containsPeer(peers, c.peer))
-
-		// non-seeder announce should still return the leecher
-		peers, err = p.AnnouncePeers(c.ih, false, 50, peer)
-		require.Nil(t, err)
-		require.True(t, containsPeer(peers, c.peer))
-
-		scrape = p.ScrapeSwarm(c.ih, c.peer.IP.AddressFamily)
-		require.Equal(t, uint32(2), scrape.Incomplete)
-		require.Equal(t, uint32(0), scrape.Complete)
-
-		err = p.DeleteLeecher(c.ih, c.peer)
-		require.Nil(t, err)
-
-		peers, err = p.AnnouncePeers(c.ih, true, 50, peer)
-		require.Nil(t, err)
-		require.False(t, containsPeer(peers, c.peer))
-
-		// Test PutSeeder -> Announce -> DeleteSeeder -> Announce
-
-		err = p.PutSeeder(c.ih, c.peer)
-		require.Nil(t, err)
-
-		// Should be leecher to see the seeder
-		peers, err = p.AnnouncePeers(c.ih, false, 50, peer)
-		require.Nil(t, err)
-		require.True(t, containsPeer(peers, c.peer))
-
-		scrape = p.ScrapeSwarm(c.ih, c.peer.IP.AddressFamily)
-		require.Equal(t, uint32(1), scrape.Incomplete)
-		require.Equal(t, uint32(1), scrape.Complete)
-
-		err = p.DeleteSeeder(c.ih, c.peer)
-		require.Nil(t, err)
-
-		peers, err = p.AnnouncePeers(c.ih, false, 50, peer)
-		require.Nil(t, err)
-		require.False(t, containsPeer(peers, c.peer))
-
-		// Test PutLeecher -> Graduate -> Announce -> DeleteLeecher -> Announce
-
-		err = p.PutLeecher(c.ih, c.peer)
-		require.Nil(t, err)
-
-		err = p.GraduateLeecher(c.ih, c.peer)
-		require.Nil(t, err)
-
-		// Has to be leecher to see the graduated seeder
-		peers, err = p.AnnouncePeers(c.ih, false, 50, peer)
-		require.Nil(t, err)
-		require.True(t, containsPeer(peers, c.peer))
-
-		// Deleting the Peer as a Leecher should have no effect
-		err = p.DeleteLeecher(c.ih, c.peer)
-		require.Equal(t, ErrResourceDoesNotExist, err)
-
-		// Verify it's still there
-		peers, err = p.AnnouncePeers(c.ih, false, 50, peer)
-		require.Nil(t, err)
-		require.True(t, containsPeer(peers, c.peer))
-
-		// Clean up
-
-		err = p.DeleteLeecher(c.ih, peer)
-		require.Nil(t, err)
-
-		// Test ErrDNE for missing leecher
-		err = p.DeleteLeecher(c.ih, peer)
-		require.Equal(t, ErrResourceDoesNotExist, err)
-
-		err = p.DeleteSeeder(c.ih, c.peer)
-		require.Nil(t, err)
-
-		err = p.DeleteSeeder(c.ih, c.peer)
-		require.Equal(t, ErrResourceDoesNotExist, err)
-	}
-
-	e := p.Stop()
-	require.Nil(t, <-e)
-}
-
-func containsPeer(peers []bittorrent.Peer, p bittorrent.Peer) bool {
-	for _, peer := range peers {
-		if PeerEqualityFunc(peer, p) {
-			return true
-		}
-	}
-	return false
-}
diff --git a/storage/storage_bench.go b/storage/test/storage_bench.go
similarity index 52%
rename from storage/storage_bench.go
rename to storage/test/storage_bench.go
index c5296ae..3e22ae0 100644
--- a/storage/storage_bench.go
+++ b/storage/test/storage_bench.go
@@ -1,6 +1,7 @@
-package storage
+package test
 
 import (
+	"github.com/chihaya/chihaya/storage"
 	"math/rand"
 	"net"
 	"runtime"
@@ -49,10 +50,16 @@ func generatePeers() (a [1000]bittorrent.Peer) {
 	return
 }
 
-type executionFunc func(int, Storage, *benchData) error
-type setupFunc func(Storage, *benchData) error
+type benchExecFunc func(int, storage.Storage, *benchData) error
+type benchSetupFunc func(storage.Storage, *benchData) error
+type benchStorageConstructor func() storage.Storage
 
-func runBenchmark(b *testing.B, ps Storage, parallel bool, sf setupFunc, ef executionFunc) {
+type benchHolder struct {
+	st benchStorageConstructor
+}
+
+func (bh *benchHolder) runBenchmark(b *testing.B, parallel bool, sf benchSetupFunc, ef benchExecFunc) {
+	ps := bh.st()
 	bd := &benchData{generateInfohashes(), generatePeers()}
 	spacing := int32(1000 / runtime.NumCPU())
 	if sf != nil {
@@ -92,65 +99,65 @@ func runBenchmark(b *testing.B, ps Storage, parallel bool, sf setupFunc, ef exec
 }
 
 // Nop executes a no-op for each iteration.
-// It should produce the same results for each Storage.
+// It should produce the same results for each storage.Storage.
 // This can be used to get an estimate of the impact of the benchmark harness
 // on benchmark results and an estimate of the general performance of the system
 // benchmarked on.
 //
 // Nop can run in parallel.
-func Nop(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, putPeers, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) Nop(b *testing.B) {
+	bh.runBenchmark(b, true, putPeers, func(i int, ps storage.Storage, bd *benchData) error {
 		return nil
 	})
 }
 
-// Put benchmarks the PutSeeder method of a Storage by repeatedly Putting the
+// Put benchmarks the PutSeeder method of a storage.Storage by repeatedly Putting the
 // same Peer for the same InfoHash.
 //
 // Put can run in parallel.
-func Put(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) Put(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		return ps.PutSeeder(bd.infohashes[0], bd.peers[0])
 	})
 }
 
-// Put1k benchmarks the PutSeeder method of a Storage by cycling through 1000
+// Put1k benchmarks the PutSeeder method of a storage.Storage by cycling through 1000
 // Peers and Putting them into the swarm of one infohash.
 //
 // Put1k can run in parallel.
-func Put1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) Put1k(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		return ps.PutSeeder(bd.infohashes[0], bd.peers[i%1000])
 	})
 }
 
-// Put1kInfohash benchmarks the PutSeeder method of a Storage by cycling
+// Put1kInfohash benchmarks the PutSeeder method of a storage.Storage by cycling
 // through 1000 infohashes and putting the same peer into their swarms.
 //
 // Put1kInfohash can run in parallel.
-func Put1kInfohash(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) Put1kInfohash(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		return ps.PutSeeder(bd.infohashes[i%1000], bd.peers[0])
 	})
 }
 
-// Put1kInfohash1k benchmarks the PutSeeder method of a Storage by cycling
+// Put1kInfohash1k benchmarks the PutSeeder method of a storage.Storage by cycling
 // through 1000 infohashes and 1000 Peers and calling Put with them.
 //
 // Put1kInfohash1k can run in parallel.
-func Put1kInfohash1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) Put1kInfohash1k(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		err := ps.PutSeeder(bd.infohashes[i%1000], bd.peers[(i*3)%1000])
 		return err
 	})
 }
 
-// PutDelete benchmarks the PutSeeder and DeleteSeeder methods of a Storage by
+// PutDelete benchmarks the PutSeeder and DeleteSeeder methods of a storage.Storage by
 // calling PutSeeder followed by DeleteSeeder for one Peer and one infohash.
 //
 // PutDelete can not run in parallel.
-func PutDelete(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, false, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) PutDelete(b *testing.B) {
+	bh.runBenchmark(b, false, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		err := ps.PutSeeder(bd.infohashes[0], bd.peers[0])
 		if err != nil {
 			return err
@@ -163,8 +170,8 @@ func PutDelete(b *testing.B, ps Storage) {
 // PutDelete does, but with one from 1000 Peers per iteration.
 //
 // PutDelete1k can not run in parallel.
-func PutDelete1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, false, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) PutDelete1k(b *testing.B) {
+	bh.runBenchmark(b, false, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		err := ps.PutSeeder(bd.infohashes[0], bd.peers[i%1000])
 		if err != nil {
 			return err
@@ -177,8 +184,8 @@ func PutDelete1k(b *testing.B, ps Storage) {
 // 1000 Peers.
 //
 // PutDelete1kInfohash can not run in parallel.
-func PutDelete1kInfohash(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, false, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) PutDelete1kInfohash(b *testing.B) {
+	bh.runBenchmark(b, false, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		err := ps.PutSeeder(bd.infohashes[i%1000], bd.peers[0])
 		if err != nil {
 		}
@@ -190,8 +197,8 @@ func PutDelete1kInfohash(b *testing.B, ps Storage) {
 // addition to 1000 Peers.
 //
 // PutDelete1kInfohash1k can not run in parallel.
-func PutDelete1kInfohash1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, false, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) PutDelete1kInfohash1k(b *testing.B) {
+	bh.runBenchmark(b, false, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		err := ps.PutSeeder(bd.infohashes[i%1000], bd.peers[(i*3)%1000])
 		if err != nil {
 			return err
@@ -201,102 +208,102 @@ func PutDelete1kInfohash1k(b *testing.B, ps Storage) {
 	})
 }
 
-// DeleteNonexist benchmarks the DeleteSeeder method of a Storage by
+// DeleteNonexist benchmarks the DeleteSeeder method of a storage.Storage by
 // attempting to delete a Peer that is nonexistent.
 //
 // DeleteNonexist can run in parallel.
-func DeleteNonexist(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
-		ps.DeleteSeeder(bd.infohashes[0], bd.peers[0])
+func (bh *benchHolder) DeleteNonexist(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
+		_ = ps.DeleteSeeder(bd.infohashes[0], bd.peers[0])
 		return nil
 	})
 }
 
-// DeleteNonexist1k benchmarks the DeleteSeeder method of a Storage by
+// DeleteNonexist1k benchmarks the DeleteSeeder method of a storage.Storage by
 // attempting to delete one of 1000 nonexistent Peers.
 //
 // DeleteNonexist can run in parallel.
-func DeleteNonexist1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
-		ps.DeleteSeeder(bd.infohashes[0], bd.peers[i%1000])
+func (bh *benchHolder) DeleteNonexist1k(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
+		_ = ps.DeleteSeeder(bd.infohashes[0], bd.peers[i%1000])
 		return nil
 	})
 }
 
-// DeleteNonexist1kInfohash benchmarks the DeleteSeeder method of a Storage by
+// DeleteNonexist1kInfohash benchmarks the DeleteSeeder method of a storage.Storage by
 // attempting to delete one Peer from one of 1000 infohashes.
 //
 // DeleteNonexist1kInfohash can run in parallel.
-func DeleteNonexist1kInfohash(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
-		ps.DeleteSeeder(bd.infohashes[i%1000], bd.peers[0])
+func (bh *benchHolder) DeleteNonexist1kInfohash(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
+		_ = ps.DeleteSeeder(bd.infohashes[i%1000], bd.peers[0])
 		return nil
 	})
 }
 
-// DeleteNonexist1kInfohash1k benchmarks the Delete method of a Storage by
+// DeleteNonexist1kInfohash1k benchmarks the Delete method of a storage.Storage by
 // attempting to delete one of 1000 Peers from one of 1000 Infohashes.
 //
 // DeleteNonexist1kInfohash1k can run in parallel.
-func DeleteNonexist1kInfohash1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
-		ps.DeleteSeeder(bd.infohashes[i%1000], bd.peers[(i*3)%1000])
+func (bh *benchHolder) DeleteNonexist1kInfohash1k(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
+		_ = ps.DeleteSeeder(bd.infohashes[i%1000], bd.peers[(i*3)%1000])
 		return nil
 	})
 }
 
-// GradNonexist benchmarks the GraduateLeecher method of a Storage by
+// GradNonexist benchmarks the GraduateLeecher method of a storage.Storage by
 // attempting to graduate a nonexistent Peer.
 //
 // GradNonexist can run in parallel.
-func GradNonexist(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
-		ps.GraduateLeecher(bd.infohashes[0], bd.peers[0])
+func (bh *benchHolder) GradNonexist(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
+		_ = ps.GraduateLeecher(bd.infohashes[0], bd.peers[0])
 		return nil
 	})
 }
 
-// GradNonexist1k benchmarks the GraduateLeecher method of a Storage by
+// GradNonexist1k benchmarks the GraduateLeecher method of a storage.Storage by
 // attempting to graduate one of 1000 nonexistent Peers.
 //
 // GradNonexist1k can run in parallel.
-func GradNonexist1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
-		ps.GraduateLeecher(bd.infohashes[0], bd.peers[i%1000])
+func (bh *benchHolder) GradNonexist1k(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
+		_ = ps.GraduateLeecher(bd.infohashes[0], bd.peers[i%1000])
 		return nil
 	})
 }
 
-// GradNonexist1kInfohash benchmarks the GraduateLeecher method of a Storage
+// GradNonexist1kInfohash benchmarks the GraduateLeecher method of a storage.Storage
 // by attempting to graduate a nonexistent Peer for one of 100 Infohashes.
 //
 // GradNonexist1kInfohash can run in parallel.
-func GradNonexist1kInfohash(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
-		ps.GraduateLeecher(bd.infohashes[i%1000], bd.peers[0])
+func (bh *benchHolder) GradNonexist1kInfohash(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
+		_ = ps.GraduateLeecher(bd.infohashes[i%1000], bd.peers[0])
 		return nil
 	})
 }
 
-// GradNonexist1kInfohash1k benchmarks the GraduateLeecher method of a Storage
+// GradNonexist1kInfohash1k benchmarks the GraduateLeecher method of a storage.Storage
 // by attempting to graduate one of 1000 nonexistent Peers for one of 1000
 // infohashes.
 //
 // GradNonexist1kInfohash1k can run in parallel.
-func GradNonexist1kInfohash1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, nil, func(i int, ps Storage, bd *benchData) error {
-		ps.GraduateLeecher(bd.infohashes[i%1000], bd.peers[(i*3)%1000])
+func (bh *benchHolder) GradNonexist1kInfohash1k(b *testing.B) {
+	bh.runBenchmark(b, true, nil, func(i int, ps storage.Storage, bd *benchData) error {
+		_ = ps.GraduateLeecher(bd.infohashes[i%1000], bd.peers[(i*3)%1000])
 		return nil
 	})
 }
 
 // PutGradDelete benchmarks the PutLeecher, GraduateLeecher and DeleteSeeder
-// methods of a Storage by adding one leecher to a swarm, promoting it to a
+// methods of a storage.Storage by adding one leecher to a swarm, promoting it to a
 // seeder and deleting the seeder.
 //
 // PutGradDelete can not run in parallel.
-func PutGradDelete(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, false, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) PutGradDelete(b *testing.B) {
+	bh.runBenchmark(b, false, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		err := ps.PutLeecher(bd.infohashes[0], bd.peers[0])
 		if err != nil {
 			return err
@@ -312,8 +319,8 @@ func PutGradDelete(b *testing.B, ps Storage) {
 // PutGradDelete1k behaves like PutGradDelete with one of 1000 Peers.
 //
 // PutGradDelete1k can not run in parallel.
-func PutGradDelete1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, false, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) PutGradDelete1k(b *testing.B) {
+	bh.runBenchmark(b, false, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		err := ps.PutLeecher(bd.infohashes[0], bd.peers[i%1000])
 		if err != nil {
 			return err
@@ -330,8 +337,8 @@ func PutGradDelete1k(b *testing.B, ps Storage) {
 // infohashes.
 //
 // PutGradDelete1kInfohash can not run in parallel.
-func PutGradDelete1kInfohash(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, false, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) PutGradDelete1kInfohash(b *testing.B) {
+	bh.runBenchmark(b, false, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		err := ps.PutLeecher(bd.infohashes[i%1000], bd.peers[0])
 		if err != nil {
 			return err
@@ -348,8 +355,8 @@ func PutGradDelete1kInfohash(b *testing.B, ps Storage) {
 // and one of 1000 infohashes.
 //
 // PutGradDelete1kInfohash can not run in parallel.
-func PutGradDelete1kInfohash1k(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, false, nil, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) PutGradDelete1kInfohash1k(b *testing.B) {
+	bh.runBenchmark(b, false, nil, func(i int, ps storage.Storage, bd *benchData) error {
 		err := ps.PutLeecher(bd.infohashes[i%1000], bd.peers[(i*3)%1000])
 		if err != nil {
 			return err
@@ -363,7 +370,7 @@ func PutGradDelete1kInfohash1k(b *testing.B, ps Storage) {
 	})
 }
 
-func putPeers(ps Storage, bd *benchData) error {
+func putPeers(ps storage.Storage, bd *benchData) error {
 	for i := 0; i < 1000; i++ {
 		for j := 0; j < 1000; j++ {
 			var err error
@@ -380,13 +387,13 @@ func putPeers(ps Storage, bd *benchData) error {
 	return nil
 }
 
-// AnnounceLeecher benchmarks the AnnouncePeers method of a Storage for
+// AnnounceLeecher benchmarks the AnnouncePeers method of a storage.Storage for
 // announcing a leecher.
 // The swarm announced to has 500 seeders and 500 leechers.
 //
 // AnnounceLeecher can run in parallel.
-func AnnounceLeecher(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, putPeers, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) AnnounceLeecher(b *testing.B) {
+	bh.runBenchmark(b, true, putPeers, func(i int, ps storage.Storage, bd *benchData) error {
 		_, err := ps.AnnouncePeers(bd.infohashes[0], false, 50, bd.peers[0])
 		return err
 	})
@@ -396,8 +403,8 @@ func AnnounceLeecher(b *testing.B, ps Storage) {
 // infohashes.
 //
 // AnnounceLeecher1kInfohash can run in parallel.
-func AnnounceLeecher1kInfohash(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, putPeers, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) AnnounceLeecher1kInfohash(b *testing.B) {
+	bh.runBenchmark(b, true, putPeers, func(i int, ps storage.Storage, bd *benchData) error {
 		_, err := ps.AnnouncePeers(bd.infohashes[i%1000], false, 50, bd.peers[0])
 		return err
 	})
@@ -407,8 +414,8 @@ func AnnounceLeecher1kInfohash(b *testing.B, ps Storage) {
 // leecher.
 //
 // AnnounceSeeder can run in parallel.
-func AnnounceSeeder(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, putPeers, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) AnnounceSeeder(b *testing.B) {
+	bh.runBenchmark(b, true, putPeers, func(i int, ps storage.Storage, bd *benchData) error {
 		_, err := ps.AnnouncePeers(bd.infohashes[0], true, 50, bd.peers[0])
 		return err
 	})
@@ -418,19 +425,19 @@ func AnnounceSeeder(b *testing.B, ps Storage) {
 // infohashes.
 //
 // AnnounceSeeder1kInfohash can run in parallel.
-func AnnounceSeeder1kInfohash(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, putPeers, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) AnnounceSeeder1kInfohash(b *testing.B) {
+	bh.runBenchmark(b, true, putPeers, func(i int, ps storage.Storage, bd *benchData) error {
 		_, err := ps.AnnouncePeers(bd.infohashes[i%1000], true, 50, bd.peers[0])
 		return err
 	})
 }
 
-// ScrapeSwarm benchmarks the ScrapeSwarm method of a Storage.
+// ScrapeSwarm benchmarks the ScrapeSwarm method of a storage.Storage.
 // The swarm scraped has 500 seeders and 500 leechers.
 //
 // ScrapeSwarm can run in parallel.
-func ScrapeSwarm(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, putPeers, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) ScrapeSwarm(b *testing.B) {
+	bh.runBenchmark(b, true, putPeers, func(i int, ps storage.Storage, bd *benchData) error {
 		ps.ScrapeSwarm(bd.infohashes[0], bittorrent.IPv4)
 		return nil
 	})
@@ -439,9 +446,40 @@ func ScrapeSwarm(b *testing.B, ps Storage) {
 // ScrapeSwarm1kInfohash behaves like ScrapeSwarm with one of 1000 infohashes.
 //
 // ScrapeSwarm1kInfohash can run in parallel.
-func ScrapeSwarm1kInfohash(b *testing.B, ps Storage) {
-	runBenchmark(b, ps, true, putPeers, func(i int, ps Storage, bd *benchData) error {
+func (bh *benchHolder) ScrapeSwarm1kInfohash(b *testing.B) {
+	bh.runBenchmark(b, true, putPeers, func(i int, ps storage.Storage, bd *benchData) error {
 		ps.ScrapeSwarm(bd.infohashes[i%1000], bittorrent.IPv4)
 		return nil
 	})
 }
+
+func RunBenchmarks(b *testing.B, newStorage benchStorageConstructor) {
+	bh := benchHolder{st: newStorage}
+	b.Run("BenchmarkNop", bh.Nop)
+	b.Run("BenchmarkPut", bh.Put)
+	b.Run("BenchmarkPut1k", bh.Put1k)
+	b.Run("BenchmarkPut1kInfohash", bh.Put1kInfohash)
+	b.Run("BenchmarkPut1kInfohash1k", bh.Put1kInfohash1k)
+	b.Run("BenchmarkPutDelete", bh.PutDelete)
+	b.Run("BenchmarkPutDelete1k", bh.PutDelete1k)
+	b.Run("BenchmarkPutDelete1kInfohash", bh.PutDelete1kInfohash)
+	b.Run("BenchmarkPutDelete1kInfohash1k", bh.PutDelete1kInfohash1k)
+	b.Run("BenchmarkDeleteNonexist", bh.DeleteNonexist)
+	b.Run("BenchmarkDeleteNonexist1k", bh.DeleteNonexist1k)
+	b.Run("BenchmarkDeleteNonexist1kInfohash", bh.DeleteNonexist1kInfohash)
+	b.Run("BenchmarkDeleteNonexist1kInfohash1k", bh.DeleteNonexist1kInfohash1k)
+	b.Run("BenchmarkPutGradDelete", bh.PutGradDelete)
+	b.Run("BenchmarkPutGradDelete1k", bh.PutGradDelete1k)
+	b.Run("BenchmarkPutGradDelete1kInfohash", bh.PutGradDelete1kInfohash)
+	b.Run("BenchmarkPutGradDelete1kInfohash1k", bh.PutGradDelete1kInfohash1k)
+	b.Run("BenchmarkGradNonexist", bh.GradNonexist)
+	b.Run("BenchmarkGradNonexist1k", bh.GradNonexist1k)
+	b.Run("BenchmarkGradNonexist1kInfohash", bh.GradNonexist1kInfohash)
+	b.Run("BenchmarkGradNonexist1kInfohash1k", bh.GradNonexist1kInfohash1k)
+	b.Run("BenchmarkAnnounceLeecher", bh.AnnounceLeecher)
+	b.Run("BenchmarkAnnounceLeecher1kInfohash", bh.AnnounceLeecher1kInfohash)
+	b.Run("BenchmarkAnnounceSeeder", bh.AnnounceSeeder)
+	b.Run("BenchmarkAnnounceSeeder1kInfohash", bh.AnnounceSeeder1kInfohash)
+	b.Run("BenchmarkScrapeSwarm", bh.ScrapeSwarm)
+	b.Run("BenchmarkScrapeSwarm1kInfohash", bh.ScrapeSwarm1kInfohash)
+}
diff --git a/storage/test/storage_test_base.go b/storage/test/storage_test_base.go
new file mode 100644
index 0000000..32920e2
--- /dev/null
+++ b/storage/test/storage_test_base.go
@@ -0,0 +1,278 @@
+package test
+
+import (
+	"github.com/chihaya/chihaya/storage"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/chihaya/chihaya/bittorrent"
+)
+
+// PeerEqualityFunc is the boolean function to use to check two Peers for
+// equality.
+// Depending on the implementation of the Storage, this can be changed to
+// use (Peer).EqualEndpoint instead.
+var PeerEqualityFunc = func(p1, p2 bittorrent.Peer) bool { return p1.Equal(p2) }
+
+type testHolder struct {
+	st storage.Storage
+}
+
+type hashPeer struct {
+	ih   bittorrent.InfoHash
+	peer bittorrent.Peer
+}
+
+func (th *testHolder) DeleteSeeder(t *testing.T) {
+	for _, c := range testData {
+		err := th.st.DeleteSeeder(c.ih, c.peer)
+		require.Equal(t, storage.ErrResourceDoesNotExist, err)
+	}
+}
+
+func (th *testHolder) PutLeecher(t *testing.T) {
+	for _, c := range testData {
+		peer := v4Peer
+		if c.peer.IP.AddressFamily == bittorrent.IPv6 {
+			peer = v6Peer
+		}
+		err := th.st.PutLeecher(c.ih, peer)
+		require.Nil(t, err)
+	}
+}
+
+func (th *testHolder) DeleteLeecher(t *testing.T) {
+	for _, c := range testData {
+		err := th.st.DeleteLeecher(c.ih, c.peer)
+		require.Equal(t, storage.ErrResourceDoesNotExist, err)
+	}
+}
+
+func (th *testHolder) AnnouncePeers(t *testing.T) {
+	for _, c := range testData {
+		peer := v4Peer
+		if c.peer.IP.AddressFamily == bittorrent.IPv6 {
+			peer = v6Peer
+		}
+		_, err := th.st.AnnouncePeers(c.ih, false, 50, peer)
+		require.Equal(t, storage.ErrResourceDoesNotExist, err)
+	}
+}
+
+func (th *testHolder) ScrapeSwarm(t *testing.T) {
+	for _, c := range testData {
+		scrape := th.st.ScrapeSwarm(c.ih, c.peer.IP.AddressFamily)
+		require.Equal(t, uint32(0), scrape.Complete)
+		require.Equal(t, uint32(0), scrape.Incomplete)
+		require.Equal(t, uint32(0), scrape.Snatches)
+	}
+}
+
+func (th *testHolder) LeecherPutAnnounceDeleteAnnounce(t *testing.T) {
+	for _, c := range testData {
+		peer := v4Peer
+		if c.peer.IP.AddressFamily == bittorrent.IPv6 {
+			peer = v6Peer
+		}
+		err := th.st.PutLeecher(c.ih, c.peer)
+		require.Nil(t, err)
+
+		peers, err := th.st.AnnouncePeers(c.ih, true, 50, peer)
+		require.Nil(t, err)
+		require.True(t, containsPeer(peers, c.peer))
+
+		// non-seeder announce should still return the leecher
+		peers, err = th.st.AnnouncePeers(c.ih, false, 50, peer)
+		require.Nil(t, err)
+		require.True(t, containsPeer(peers, c.peer))
+
+		scrape := th.st.ScrapeSwarm(c.ih, c.peer.IP.AddressFamily)
+		require.Equal(t, uint32(2), scrape.Incomplete)
+		require.Equal(t, uint32(0), scrape.Complete)
+
+		err = th.st.DeleteLeecher(c.ih, c.peer)
+		require.Nil(t, err)
+
+		peers, err = th.st.AnnouncePeers(c.ih, true, 50, peer)
+		require.Nil(t, err)
+		require.False(t, containsPeer(peers, c.peer))
+	}
+}
+
+func (th *testHolder) SeederPutAnnounceDeleteAnnounce(t *testing.T) {
+	for _, c := range testData {
+		peer := v4Peer
+		if c.peer.IP.AddressFamily == bittorrent.IPv6 {
+			peer = v6Peer
+		}
+		err := th.st.PutSeeder(c.ih, c.peer)
+		require.Nil(t, err)
+
+		// Should be leecher to see the seeder
+		peers, err := th.st.AnnouncePeers(c.ih, false, 50, peer)
+		require.Nil(t, err)
+		require.True(t, containsPeer(peers, c.peer))
+
+		scrape := th.st.ScrapeSwarm(c.ih, c.peer.IP.AddressFamily)
+		require.Equal(t, uint32(1), scrape.Incomplete)
+		require.Equal(t, uint32(1), scrape.Complete)
+
+		err = th.st.DeleteSeeder(c.ih, c.peer)
+		require.Nil(t, err)
+
+		peers, err = th.st.AnnouncePeers(c.ih, false, 50, peer)
+		require.Nil(t, err)
+		require.False(t, containsPeer(peers, c.peer))
+	}
+}
+
+func (th *testHolder) LeecherPutGraduateAnnounceDeleteAnnounce(t *testing.T) {
+	for _, c := range testData {
+		peer := v4Peer
+		if c.peer.IP.AddressFamily == bittorrent.IPv6 {
+			peer = v6Peer
+		}
+		err := th.st.PutLeecher(c.ih, c.peer)
+		require.Nil(t, err)
+
+		err = th.st.GraduateLeecher(c.ih, c.peer)
+		require.Nil(t, err)
+
+		// Has to be leecher to see the graduated seeder
+		peers, err := th.st.AnnouncePeers(c.ih, false, 50, peer)
+		require.Nil(t, err)
+		require.True(t, containsPeer(peers, c.peer))
+
+		// Deleting the Peer as a Leecher should have no effect
+		err = th.st.DeleteLeecher(c.ih, c.peer)
+		require.Equal(t, storage.ErrResourceDoesNotExist, err)
+
+		// Verify it's still there
+		peers, err = th.st.AnnouncePeers(c.ih, false, 50, peer)
+		require.Nil(t, err)
+		require.True(t, containsPeer(peers, c.peer))
+
+		// Clean up
+		err = th.st.DeleteLeecher(c.ih, peer)
+		require.Nil(t, err)
+
+		// Test ErrDNE for missing leecher
+		err = th.st.DeleteLeecher(c.ih, peer)
+		require.Equal(t, storage.ErrResourceDoesNotExist, err)
+
+		err = th.st.DeleteSeeder(c.ih, c.peer)
+		require.Nil(t, err)
+
+		err = th.st.DeleteSeeder(c.ih, c.peer)
+		require.Equal(t, storage.ErrResourceDoesNotExist, err)
+	}
+}
+
+func (th *testHolder) CustomPutContainsLoadDelete(t *testing.T) {
+	for _, c := range testData {
+		th.st.Put("test", c.peer.String(), c.ih.RawString())
+
+		// check if exist in ctx we put
+		contains := th.st.Contains("test", c.peer.String())
+		require.True(t, contains)
+
+		// check if not exist in another ctx
+		contains = th.st.Contains("", c.peer.String())
+		require.False(t, contains)
+
+		// check value and type in ctx we put
+		out := th.st.Load("test", c.peer.String())
+		ih, err := bittorrent.NewInfoHash(out)
+		require.Nil(t, err)
+		require.Equal(t, c.ih, ih)
+
+		// check value is nil in another ctx
+		dummy := th.st.Load("", c.peer.String())
+		require.Nil(t, dummy)
+
+		th.st.Delete("test", c.peer.String())
+
+		contains = th.st.Contains("peers", c.peer.String())
+		require.False(t, contains)
+	}
+}
+
+func (th *testHolder) CustomBulkPutContainsLoadDelete(t *testing.T) {
+	pairs := make([]storage.Pair, 0, len(testData))
+	keys := make([]interface{}, 0, len(testData))
+	for _, c := range testData {
+		key := c.peer.String()
+		keys = append(keys, key)
+		pairs = append(pairs, storage.Pair{
+			Left:  key,
+			Right: c.ih.RawString(),
+		})
+	}
+	th.st.BulkPut("test", pairs...)
+
+	// check if exist in ctx we put
+	for _, k := range keys {
+		contains := th.st.Contains("test", k)
+		require.True(t, contains)
+	}
+
+	// check value and type in ctx we put
+	for _, p := range pairs {
+		out := th.st.Load("test", p.Left)
+		ih, err := bittorrent.NewInfoHash(out)
+		require.Nil(t, err)
+		require.Equal(t, p.Right, ih.RawString())
+	}
+
+	th.st.Delete("test", keys...)
+
+	for _, k := range keys {
+		contains := th.st.Contains("test", k)
+		require.False(t, contains)
+	}
+}
+
+// RunTests tests a Storage implementation against the interface.
+func RunTests(t *testing.T, p storage.Storage) {
+	th := testHolder{st: p}
+
+	// Test ErrDNE for non-existent swarms.
+	t.Run("DeleteLeecher", th.DeleteLeecher)
+	t.Run("DeleteSeeder", th.DeleteSeeder)
+	t.Run("AnnouncePeers", th.AnnouncePeers)
+
+	// Test empty scrape response for non-existent swarms.
+	t.Run("ScrapeSwarm", th.ScrapeSwarm)
+
+	// Insert dummy Peer to keep swarm active
+	// Has the same address family as c.peer
+	t.Run("PutLeecher", th.PutLeecher)
+
+	// Test ErrDNE for non-existent seeder.
+	t.Run("DeleteSeeder", th.DeleteSeeder)
+
+	// Test PutLeecher -> Announce -> DeleteLeecher -> Announce
+	t.Run("LeecherPutAnnounceDeleteAnnounce", th.LeecherPutAnnounceDeleteAnnounce)
+
+	// Test PutSeeder -> Announce -> DeleteSeeder -> Announce
+	t.Run("SeederPutAnnounceDeleteAnnounce", th.SeederPutAnnounceDeleteAnnounce)
+
+	// Test PutLeecher -> Graduate -> Announce -> DeleteLeecher -> Announce
+	t.Run("LeecherPutGraduateAnnounceDeleteAnnounce", th.LeecherPutGraduateAnnounceDeleteAnnounce)
+
+	t.Run("CustomPutContainsLoadDelete", th.CustomPutContainsLoadDelete)
+	t.Run("CustomBulkPutContainsLoadDelete", th.CustomBulkPutContainsLoadDelete)
+
+	e := th.st.Stop()
+	require.Nil(t, <-e)
+}
+
+func containsPeer(peers []bittorrent.Peer, p bittorrent.Peer) bool {
+	for _, peer := range peers {
+		if PeerEqualityFunc(peer, p) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/storage/test/storage_test_data.go b/storage/test/storage_test_data.go
new file mode 100644
index 0000000..e3289bb
--- /dev/null
+++ b/storage/test/storage_test_data.go
@@ -0,0 +1,32 @@
+package test
+
+import (
+	"github.com/chihaya/chihaya/bittorrent"
+	"net"
+)
+
+var (
+	testIh1, testIh2 bittorrent.InfoHash
+	testPeerId       bittorrent.PeerID
+	testData         []hashPeer
+	v4Peer, v6Peer   bittorrent.Peer
+)
+
+func init() {
+	testIh1, _ = bittorrent.NewInfoHash("00000000000000000001")
+	testIh2, _ = bittorrent.NewInfoHash("00000000000000000002")
+	testPeerId, _ = bittorrent.NewPeerID([]byte("00000000000000000001"))
+	testData = []hashPeer{
+		{
+			testIh1,
+			bittorrent.Peer{ID: testPeerId, Port: 1, IP: bittorrent.IP{IP: net.ParseIP("1.1.1.1").To4(), AddressFamily: bittorrent.IPv4}},
+		},
+		{
+			testIh2,
+			bittorrent.Peer{ID: testPeerId, Port: 2, IP: bittorrent.IP{IP: net.ParseIP("abab::0001"), AddressFamily: bittorrent.IPv6}},
+		},
+	}
+
+	v4Peer = bittorrent.Peer{ID: testPeerId, IP: bittorrent.IP{IP: net.ParseIP("99.99.99.99").To4(), AddressFamily: bittorrent.IPv4}, Port: 9994}
+	v6Peer = bittorrent.Peer{ID: testPeerId, IP: bittorrent.IP{IP: net.ParseIP("fc00::0001"), AddressFamily: bittorrent.IPv6}, Port: 9996}
+}