Merge branch 'master' into ely

Restore Ely documentation link on the 404 page
Restore Ely signed textures ely property
2025-05-31 14:11:51 +05:30 · 2018-02-17 01:52:47 +03:00 · 2018-02-16 21:01:01 +03:00 · 2018-02-16 21:01:01 +03:00 · 2018-02-16 21:01:01 +03:00
90 changed files with 2734 additions and 7711 deletions
--- a/.fossa.yml
+++ b/.fossa.yml
@@ -1,13 +0,0 @@
-version: 2
-cli:
-  server: https://app.fossa.com
-  fetcher: git
-  project: github.com:elyby/chrly
-analyze:
-  modules:
-    - name: chrly
-      type: go
-      target: github.com/elyby/chrly
-      path: .
-      options:
-        strategy: dep
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,63 +1,41 @@
-os: linux
-dist: xenial
+sudo: required
+
 language: go
 go:
-  - "1.14"
+  - 1.9
+
+services:
+  - docker

 stages:
-  - Tests
-  - name: Deploy
-    if: env(TRAVIS_PULL_REQUEST) IS false AND (branch = master OR tag IS present) AND commit_message !~ /(\[skip deploy\])/
+  - test
+  - name: deploy
+    if: branch = master OR tag IS present

 install:
  - go get -u github.com/golang/dep/cmd/dep
  - dep ensure

-cache:
-  directories:
-    - $GOPATH/pkg/dep
-
 jobs:
  include:
-    # Tests stage
-    - name: Unit tests
-      stage: Tests
-      services:
-        - redis
+    - stage: test
      script:
-        - go test -v -race --tags redis -coverprofile=coverage.txt -covermode=atomic ./...
-        - bash <(curl -s https://codecov.io/bash)
-
-    - name: FOSSA
-      stage: Tests
-      if: branch = master
-      before_script:
-        - curl https://raw.githubusercontent.com/fossas/fossa-cli/master/install.sh | bash
+      - go test -v -race ./...
+    - stage: deploy
      script:
-        - fossa init
-        - fossa analyze
-        # Disable until https://github.com/fossas/fossa-cli/issues/596 will be resolved
-        # - fossa test
-
-    # Deploy stage
-    - name: Docker image
-      stage: Deploy
-      services:
-        - docker
-      script:
-        - docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
-        - export DOCKER_TAG="${TRAVIS_TAG:-dev}"
-        - export APP_VERSION="${TRAVIS_TAG:-dev-${TRAVIS_COMMIT:0:7}}"
-        - >
-          env CGO_ENABLED=0 GOOS=linux GOARCH=amd64
-          go build
-          -o release/chrly
-          -ldflags '-extldflags "-static" -X github.com/elyby/chrly/version.version=$APP_VERSION -X github.com/elyby/chrly/version.commit=$TRAVIS_COMMIT'
-          main.go
-        - docker build -t elyby/chrly:$DOCKER_TAG .
-        - docker push elyby/chrly:$DOCKER_TAG
-        - |
-          if [ ! -z ${TRAVIS_TAG+x} ] && [[ "$TRAVIS_TAG" != *"-"* ]]; then
-            docker tag elyby/chrly:$DOCKER_TAG elyby/chrly:latest
-            docker push elyby/chrly:latest
-          fi
+      - docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
+      - export DOCKER_TAG="${TRAVIS_TAG:-dev}"
+      - export APP_VERSION="${TRAVIS_TAG:-dev-${TRAVIS_COMMIT:0:7}}"
+      - >
+        env CGO_ENABLED=0 GOOS=linux GOARCH=amd64
+        go build
+        -o release/chrly
+        -ldflags '-extldflags "-static" -X github.com/elyby/chrly/bootstrap.version=$APP_VERSION'
+        main.go
+      - docker build -t elyby/chrly:$DOCKER_TAG .
+      - docker push elyby/chrly:$DOCKER_TAG
+      - |
+        if [ -z ${TRAVIS_TAG+x} ]; then
+          docker tag elyby/chrly:$DOCKER_TAG elyby/chrly:latest
+          docker push elyby/chrly:latest
+        fi
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,125 +0,0 @@
-# Changelog
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased] - xxxx-xx-xx
-
-## [4.4.0] - 2020-04-22
-### Added
- Mojang textures queue now can be completely disabled via `MOJANG_TEXTURES_ENABLED` param.
- Remote mode for Mojang's textures queue with a new configuration params: `MOJANG_TEXTURES_UUIDS_PROVIDER_DRIVER` and
-  `MOJANG_TEXTURES_UUIDS_PROVIDER_URL`.
-
-  For example, to send requests directly to [Mojang's APIs](https://wiki.vg/Mojang_API#Username_-.3E_UUID_at_time),
-  set the next configuration:
-  - `MOJANG_TEXTURES_UUIDS_PROVIDER_DRIVER=remote`
-  - `MOJANG_TEXTURES_UUIDS_PROVIDER_URL=https://api.mojang.com/users/profiles/minecraft/`
- Implemented worker mode. The app starts with the only one API endpoint: `/api/worker/mojang-uuid/{username}`,
-  which is compatible with [Mojang's endpoint](https://wiki.vg/Mojang_API#Username_-.3E_UUID_at_time) to exchange
-  username to its UUID. It can be used with some load balancing software to increase throughput of Mojang's textures
-  proxy by splitting the load across multiple servers with its own IPs.
- Textures extra param is now can be configured via `TEXTURES_EXTRA_PARAM_NAME` and `TEXTURES_EXTRA_PARAM_VALUE`.
- New StatsD metrics:
-  - Counters:
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.textures_hit`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.textures_miss`
- All incoming requests are now logging to the console in
-  [Apache Common Log Format](http://httpd.apache.org/docs/2.2/logs.html#common).
- Added `/healthcheck` endpoint.
- Graceful server shutdown.
- Panics in http are now logged in Sentry.
-
-### Fixed
- `ely.skinsystem.{hostname}.app.mojang_textures.usernames.iteration_size` and
-  `ely.skinsystem.{hostname}.app.mojang_textures.usernames.queue_size` are now updates even if the queue is empty.
- Don't return an empty object if Mojang's textures don't contain any skin or cape.
- Provides a correct URL scheme for the cape link.
-
-### Changed
- **BREAKING**: `QUEUE_LOOP_DELAY` param is now sets as a Go duration, not milliseconds.
-  For example, default value is now `2s500ms`.
- **BREAKING**: Event `ely.skinsystem.{hostname}.app.mojang_textures.already_in_queue` has been renamed into
-  `ely.skinsystem.{hostname}.app.mojang_textures.already_scheduled`.
- Bumped Go version to 1.14.
-
-### Removed
- **BREAKING**: `ely.skinsystem.{hostname}.app.mojang_textures.invalid_username` counter has been removed.
-
-## [4.3.0] - 2019-11-08
-### Added
- 403 Forbidden errors from the Mojang's API are now logged.
- `QUEUE_LOOP_DELAY` configuration param to adjust Mojang's textures queue performance.
-
-### Changed
- Mojang's textures queue loop is now has an iteration delay of 2.5 seconds (was 1).
- Bumped Go version to 1.13.
-
-## [4.2.3] - 2019-10-03
-### Changed
- Mojang's textures queue batch size [reduced to 10](https://wiki.vg/index.php?title=Mojang_API&type=revision&diff=14964&oldid=14954).
- 400 BadRequest errors from the Mojang's API are now logged.
-
-## [4.2.2] - 2019-06-19
-### Fixed
- GC for in-memory textures cache has not been initialized.
-
-## [4.2.1] - 2019-05-06
-### Changed
- Improved Keep-Alive settings for HTTP client used to perform requests to Mojang's APIs.
- Mojang's textures queue now has static delay of 1 second after each iteration to prevent strange `429` errors.
- Mojang's textures queue now caches even errored responses for signed textures to avoid `429` errors.
- Mojang's textures queue now caches textures data for 70 seconds to avoid strange `429` errors.
- Mojang's textures queue now doesn't log timeout errors.
-
-### Fixed
- Panic when Redis connection is broken.
- Duplication of Redis connections pool for Mojang's textures queue.
- Removed validation rules for `hash` field.
-
-## [4.2.0] - 2019-05-02
-### Added
- `CHANGELOG.md` file.
- [#1](https://github.com/elyby/chrly/issues/1): Restored Mojang skins proxy.
- New StatsD metrics:
-  - Counters:
-    - `ely.skinsystem.{hostname}.app.mojang_textures.invalid_username`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.request`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.cache_hit_nil`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.queued`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.cache_hit`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.already_in_queue`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.uuid_miss`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.uuid_hit`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.textures.cache_hit`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.textures.request`
-  - Gauges:
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.iteration_size`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.queue_size`
-  - Timers:
-    - `ely.skinsystem.{hostname}.app.mojang_textures.result_time`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.round_time`
-    - `ely.skinsystem.{hostname}.app.mojang_textures.textures.request_time`
-
-### Changed
- Bumped Go version to 1.12.
- Bumped Alpine version to 3.9.3.
-
-### Fixed
- `/textures` request no longer proxies request to Mojang in a case when there is no information about the skin,
-  but there is a cape.
- [#5](https://github.com/elyby/chrly/issues/5): Return Redis connection to the pool after commands are executed
-
-### Removed
- `hash` field from `/textures` response because the game doesn't use it and calculates hash by getting the filename
-  from the textures link instead.
- `hash` field from `POST /api/skins` endpoint.
-
-[Unreleased]: https://github.com/elyby/chrly/compare/4.4.0...HEAD
-[4.4.0]: https://github.com/elyby/chrly/compare/4.3.0...4.4.0
-[4.3.0]: https://github.com/elyby/chrly/compare/4.2.3...4.3.0
-[4.2.3]: https://github.com/elyby/chrly/compare/4.2.2...4.2.3
-[4.2.2]: https://github.com/elyby/chrly/compare/4.2.1...4.2.2
-[4.2.1]: https://github.com/elyby/chrly/compare/4.2.0...4.2.1
-[4.2.0]: https://github.com/elyby/chrly/compare/4.1.1...4.2.0
--- a/4
+++ b/4
@@ -1,9 +1,7 @@
-FROM alpine:3.9.3
+FROM alpine:3.7

 EXPOSE 80

-RUN apk add --no-cache ca-certificates
-
 ENV STORAGE_REDIS_HOST=redis
 ENV STORAGE_FILESYSTEM_HOST=/data

--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -2,358 +2,183 @@


 [[projects]]
-  digest = "1:8855efc2aff3afd6319da41b22a8ca1cfd1698af05a24852c01636ba65b133f0"
  name = "github.com/SermoDigital/jose"
-  packages = [
-    ".",
-    "crypto",
-    "jws",
-    "jwt",
-  ]
-  pruneopts = ""
+  packages = [".","crypto","jws","jwt"]
  revision = "f6df55f235c24f236d11dbcf665249a59ac2021f"
  version = "1.1"

 [[projects]]
-  branch = "publish_nil_values"
-  digest = "1:d02c8323070a3d8d8ca039d0d180198ead0a75eac4fb1003af812435a2b391e8"
-  name = "github.com/asaskevich/EventBus"
-  packages = ["."]
-  pruneopts = ""
-  revision = "33b3bc6a7ddca2f99683c5c3ee86b24f80a7a075"
-  source = "https://github.com/erickskrauch/EventBus.git"
-
-[[projects]]
-  digest = "1:c7b11da9bf0707e6920e1b361fbbbbe9b277ef3a198377baa4527f6e31049be0"
  name = "github.com/certifi/gocertifi"
  packages = ["."]
-  pruneopts = ""
  revision = "3fd9e1adb12b72d2f3f82191d49be9b93c69f67c"
  version = "2017.07.27"

 [[projects]]
-  digest = "1:56c130d885a4aacae1dd9c7b71cfe39912c7ebc1ff7d2b46083c8812996dc43b"
  name = "github.com/davecgh/go-spew"
  packages = ["spew"]
-  pruneopts = ""
  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
  version = "v1.1.0"

 [[projects]]
-  digest = "1:2e7c296138d042515eb2995fe58026eaef2c08f660a5f36584faecf34eea3cf0"
-  name = "github.com/etherlabsio/healthcheck"
-  packages = ["."]
-  pruneopts = ""
-  revision = "dd3d2fd8c3f620a32b7f3cd9b4f0d2f7d0875ab1"
-  version = "2.0.3"
-
-[[projects]]
-  digest = "1:9f1e571696860f2b4f8a241b43ce91c6085e7aaed849ccca53f590a4dc7b95bd"
  name = "github.com/fsnotify/fsnotify"
  packages = ["."]
-  pruneopts = ""
  revision = "629574ca2a5df945712d3079857300b5e4da0236"
  version = "v1.4.2"

 [[projects]]
  branch = "master"
-  digest = "1:904b0b847f705de43c15e6c8f3dd639044db5601dedfb2f3fdb3021a28491d15"
  name = "github.com/getsentry/raven-go"
  packages = ["."]
-  pruneopts = ""
-  revision = "919484f041ea21e7e27be291cee1d6af7bc98864"
+  revision = "d175f85701dfbf44cb0510114c9943e665e60907"

 [[projects]]
-  branch = "master"
-  digest = "1:8c9f13aac9e92f3754ea591b39ada87b9f89f1e75c4b90ccbd0b1084069c436f"
-  name = "github.com/goava/di"
-  packages = [
-    ".",
-    "internal/reflection",
-    "internal/stacktrace",
-  ]
-  pruneopts = ""
-  revision = "1eb6eb721bf050edff0efbf15c31636def701b4b"
+  name = "github.com/golang/mock"
+  packages = ["gomock"]
+  revision = "13f360950a79f5864a972c786a10a50e44b69541"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/gorilla/context"
+  packages = ["."]
+  revision = "1ea25387ff6f684839d82767c1733ff4d4d15d0a"
+  version = "v1.1"

 [[projects]]
-  digest = "1:65c7ed49d9f36dd4752e43013323fa9229db60b29aa4f5a75aaecda3130c74e2"
  name = "github.com/gorilla/mux"
  packages = ["."]
-  pruneopts = ""
-  revision = "c5c6c98bc25355028a63748a498942a6398ccd22"
-  version = "v1.7.1"
-
-[[projects]]
-  digest = "1:5eeb4bfc6db411dbb34a6d9e5d49a9956b160d59fd004ee8f03fe53c9605c082"
-  name = "github.com/h2non/gock"
-  packages = ["."]
-  pruneopts = ""
-  revision = "ba88c4862a27596539531ce469478a91bc5a0511"
-  version = "v1.0.14"
-
-[[projects]]
-  digest = "1:0f31ddb2589297fc1d716f45b34e34bff34e968de1aa239543274c87522e86f4"
-  name = "github.com/h2non/parth"
-  packages = ["."]
-  pruneopts = ""
-  revision = "b4df798d65426f8c8ab5ca5f9987aec5575d26c9"
-  version = "v2.0.1"
+  revision = "bcd8bc72b08df0f70df986b97f95590779502d31"
+  version = "v1.4.0"

 [[projects]]
  branch = "master"
-  digest = "1:8017a99c7fa4dac90c7a34e08d5f890043fc27e91e561f3267a09f65595b158c"
  name = "github.com/hashicorp/hcl"
-  packages = [
-    ".",
-    "hcl/ast",
-    "hcl/parser",
-    "hcl/printer",
-    "hcl/scanner",
-    "hcl/strconv",
-    "hcl/token",
-    "json/parser",
-    "json/scanner",
-    "json/token",
-  ]
-  pruneopts = ""
+  packages = [".","hcl/ast","hcl/parser","hcl/scanner","hcl/strconv","hcl/token","json/parser","json/scanner","json/token"]
  revision = "8f6b1344a92ff8877cf24a5de9177bf7d0a2a187"

 [[projects]]
-  digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
  name = "github.com/inconshreveable/mousetrap"
  packages = ["."]
-  pruneopts = ""
  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
  version = "v1.0"

 [[projects]]
-  digest = "1:1ce378ab2352c756c6d7a0172c22ecbd387659d32712a4ce3bc474273309a5dc"
  name = "github.com/magiconair/properties"
  packages = ["."]
-  pruneopts = ""
  revision = "be5ece7dd465ab0765a9682137865547526d1dfb"
  version = "v1.7.3"

 [[projects]]
  branch = "master"
-  digest = "1:19a9f4143462f07553e9bf6ae0f1b8633a2c44763b1df90d4e9e49f51cd8423a"
  name = "github.com/mediocregopher/radix.v2"
-  packages = [
-    "cluster",
-    "pool",
-    "redis",
-    "util",
-  ]
-  pruneopts = ""
-  revision = "b67df6e626f993b64b3ca9f4b8630900e61002e3"
+  packages = ["cluster","pool","redis","util"]
+  revision = "d234cfb904a91daafa4e1f92599a893b349cc0c2"

 [[projects]]
  branch = "master"
-  digest = "1:c9ede10a9ded782d25d1f0be87c680e11409c23554828f19a19d691a95e76130"
  name = "github.com/mitchellh/mapstructure"
  packages = ["."]
-  pruneopts = ""
  revision = "d0303fe809921458f417bcf828397a65db30a7e4"

 [[projects]]
  branch = "master"
-  digest = "1:c62e653e0a78bcf08fd56c764e5725e604693ffbd35b2b283b360f174d073a75"
  name = "github.com/mono83/slf"
-  packages = [
-    ".",
-    "filters",
-    "params",
-    "rays",
-    "recievers",
-    "recievers/sentry",
-    "recievers/statsd",
-    "recievers/writer",
-    "wd",
-  ]
-  pruneopts = ""
+  packages = [".","filters","params","rays","recievers","recievers/sentry","recievers/statsd","recievers/writer","wd"]
  revision = "79153e9636db86e1c6b74d74dd04176f257a4f2d"

 [[projects]]
  branch = "master"
-  digest = "1:270261c28f6e71a8a31b9d308ec9145147040fd80d21563307767a8e844bfabc"
  name = "github.com/mono83/udpwriter"
  packages = ["."]
-  pruneopts = ""
  revision = "a064bd7e3acfda563ea680b913b9ef24b7a73e15"

 [[projects]]
-  digest = "1:049b5bee78dfdc9628ee0e557219c41f683e5b06c5a5f20eaba0105ccc586689"
  name = "github.com/pelletier/go-buffruneio"
  packages = ["."]
-  pruneopts = ""
  revision = "c37440a7cf42ac63b919c752ca73a85067e05992"
  version = "v0.2.0"

 [[projects]]
-  digest = "1:6d5a9728ae27e477a07bb69f02ea0bade74eb8b0c7346d046337904bbf7af065"
  name = "github.com/pelletier/go-toml"
  packages = ["."]
-  pruneopts = ""
  revision = "5ccdfb18c776b740aecaf085c4d9a2779199c279"
  version = "v1.0.0"

 [[projects]]
-  digest = "1:256484dbbcd271f9ecebc6795b2df8cad4c458dd0f5fd82a8c2fa0c29f233411"
  name = "github.com/pmezard/go-difflib"
  packages = ["difflib"]
-  pruneopts = ""
  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
  version = "v1.0.0"

 [[projects]]
  branch = "master"
-  digest = "1:c189f11a84aa8b868a4b7cd4605653160424ab299cf7cfb1c5bd2740b949928f"
  name = "github.com/spf13/afero"
-  packages = [
-    ".",
-    "mem",
-  ]
-  pruneopts = ""
+  packages = [".","mem"]
  revision = "ee1bd8ee15a1306d1f9201acc41ef39cd9f99a1b"

 [[projects]]
-  digest = "1:6ff9b74bfea2625f805edec59395dc37e4a06458dd3c14e3372337e3d35a2ed6"
  name = "github.com/spf13/cast"
  packages = ["."]
-  pruneopts = ""
  revision = "acbeb36b902d72a7a4c18e8f3241075e7ab763e4"
  version = "v1.1.0"

 [[projects]]
-  digest = "1:a1403cc8a94b8d7956ee5e9694badef0e7b051af289caad1cf668331e3ffa4f6"
+  branch = "master"
  name = "github.com/spf13/cobra"
  packages = ["."]
-  pruneopts = ""
-  revision = "ef82de70bb3f60c65fb8eebacbb2d122ef517385"
-  version = "v0.0.3"
+  revision = "0c34d16c3123764e413b9ed982ada58b1c3d53ea"

 [[projects]]
  branch = "master"
-  digest = "1:5cb42b990db5dc48b8bc23b6ee77b260713ba3244ca495cd1ed89533dc482a49"
  name = "github.com/spf13/jwalterweatherman"
  packages = ["."]
-  pruneopts = ""
  revision = "12bd96e66386c1960ab0f74ced1362f66f552f7b"

 [[projects]]
-  digest = "1:cbaf13cdbfef0e4734ed8a7504f57fe893d471d62a35b982bf6fb3f036449a66"
  name = "github.com/spf13/pflag"
  packages = ["."]
-  pruneopts = ""
-  revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
-  version = "v1.0.3"
+  revision = "e57e3eeb33f795204c1ca35f56c44f83227c6e66"
+  version = "v1.0.0"

 [[projects]]
-  digest = "1:90fe60ab6f827e308b0c8cc1e11dce8ff1e96a927c8b171271a3cb04dd517606"
  name = "github.com/spf13/viper"
  packages = ["."]
-  pruneopts = ""
-  revision = "9e56dacc08fbbf8c9ee2dbc717553c758ce42bc9"
-  version = "v1.3.2"
+  revision = "25b30aa063fc18e48662b86996252eabdcf2f0c7"
+  version = "v1.0.0"

 [[projects]]
-  digest = "1:711eebe744c0151a9d09af2315f0bb729b2ec7637ef4c410fa90a18ef74b65b6"
-  name = "github.com/stretchr/objx"
-  packages = ["."]
-  pruneopts = ""
-  revision = "477a77ecc69700c7cdeb1fa9e129548e1c1c393c"
-  version = "v0.1.1"
-
-[[projects]]
-  digest = "1:381bcbeb112a51493d9d998bbba207a529c73dbb49b3fd789e48c63fac1f192c"
  name = "github.com/stretchr/testify"
-  packages = [
-    "assert",
-    "mock",
-    "require",
-    "suite",
-  ]
-  pruneopts = ""
-  revision = "ffdc059bfe9ce6a4e144ba849dbedead332c6053"
-  version = "v1.3.0"
+  packages = ["assert"]
+  revision = "69483b4bd14f5845b5a1e55bca19e954e827f1d0"
+  version = "v1.1.4"

 [[projects]]
-  branch = "master"
-  digest = "1:86e6712cfd4070a2120c03fcec41cfcbbc51813504a74e28d74479edfaf669ee"
-  name = "github.com/tevino/abool"
-  packages = ["."]
-  pruneopts = ""
-  revision = "9b9efcf221b50905aab9bbabd3daed56dc10f339"
-
-[[projects]]
-  digest = "1:061754b9de261d8e1cf804970dff7b3e105d1cb4883ef446dbe911489ba8e9eb"
+  branch = "issue-18"
  name = "github.com/thedevsaddam/govalidator"
  packages = ["."]
-  pruneopts = ""
-  revision = "0413a0eb80cac8ab2d666639130658ce49a0c967"
-  version = "v1.9.6"
+  revision = "59055296916bb3c6ad9cf3b21d5f2cf7059f8e76"
+  source = "https://github.com/erickskrauch/govalidator.git"

 [[projects]]
  branch = "master"
-  digest = "1:19adc71218d62052cd18b83ebaab77961378876094081f4b1581ca28ef80395d"
  name = "golang.org/x/sys"
  packages = ["unix"]
-  pruneopts = ""
  revision = "7ddbeae9ae08c6a06a59597f0c9edbc5ff2444ce"

 [[projects]]
  branch = "master"
-  digest = "1:653926785eac385fd1d61dc16360a5194c68d4bf2541234363a9375d2e88a039"
  name = "golang.org/x/text"
-  packages = [
-    "internal/gen",
-    "internal/triegen",
-    "internal/ucd",
-    "transform",
-    "unicode/cldr",
-    "unicode/norm",
-  ]
-  pruneopts = ""
+  packages = ["internal/gen","internal/triegen","internal/ucd","transform","unicode/cldr","unicode/norm"]
  revision = "bd91bbf73e9a4a801adbfb97133c992678533126"

 [[projects]]
  branch = "v2"
-  digest = "1:81314a486195626940617e43740b4fa073f265b0715c9f54ce2027fee1cb5f61"
  name = "gopkg.in/yaml.v2"
  packages = ["."]
-  pruneopts = ""
  revision = "eb3733d160e74a9c7e442f435eb3bea458e1d19f"

 [solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
-  input-imports = [
-    "github.com/SermoDigital/jose/crypto",
-    "github.com/SermoDigital/jose/jws",
-    "github.com/asaskevich/EventBus",
-    "github.com/etherlabsio/healthcheck",
-    "github.com/getsentry/raven-go",
-    "github.com/goava/di",
-    "github.com/gorilla/mux",
-    "github.com/h2non/gock",
-    "github.com/mediocregopher/radix.v2/pool",
-    "github.com/mediocregopher/radix.v2/redis",
-    "github.com/mediocregopher/radix.v2/util",
-    "github.com/mono83/slf",
-    "github.com/mono83/slf/params",
-    "github.com/mono83/slf/rays",
-    "github.com/mono83/slf/recievers/sentry",
-    "github.com/mono83/slf/recievers/statsd",
-    "github.com/mono83/slf/recievers/writer",
-    "github.com/mono83/slf/wd",
-    "github.com/spf13/cobra",
-    "github.com/spf13/viper",
-    "github.com/stretchr/testify/assert",
-    "github.com/stretchr/testify/mock",
-    "github.com/stretchr/testify/require",
-    "github.com/stretchr/testify/suite",
-    "github.com/tevino/abool",
-    "github.com/thedevsaddam/govalidator",
-  ]
+  inputs-digest = "e6bd87f630333e3e5b03bea33720c3281a9094551bd5ced436062157fe51ab71"
  solver-name = "gps-cdcl"
  solver-version = 1
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -2,27 +2,23 @@ ignored = ["github.com/elyby/chrly"]

 [[constraint]]
  name = "github.com/gorilla/mux"
-  version = "^1.6.1"
+  version = "1.4.0"

 [[constraint]]
  name = "github.com/mediocregopher/radix.v2"
-  branch = "master"

 [[constraint]]
  name = "github.com/mono83/slf"
-  branch = "master"

 [[constraint]]
  name = "github.com/spf13/cobra"
-  version = "^0.0.3"
+  branch = "master"

 [[constraint]]
  name = "github.com/spf13/viper"
-  version = "^1.0.0"

 [[constraint]]
  name = "github.com/getsentry/raven-go"
-  branch = "master"

 [[constraint]]
  name = "github.com/SermoDigital/jose"
@@ -30,31 +26,19 @@ ignored = ["github.com/elyby/chrly"]

 [[constraint]]
  name = "github.com/thedevsaddam/govalidator"
-  version = "^1.9.6"
-
-[[constraint]]
-  name = "github.com/tevino/abool"
-  branch = "master"
-
-[[constraint]]
-  name = "github.com/asaskevich/EventBus"
-  source = "https://github.com/erickskrauch/EventBus.git"
-  branch = "publish_nil_values"
-
-[[constraint]]
-  name = "github.com/etherlabsio/healthcheck"
-  version = "2.0.3"
-
-[[constraint]]
-  name = "github.com/goava/di"
-  branch = "master"
+  source = "https://github.com/erickskrauch/govalidator.git"
+  branch = "issue-18"

 # Testing dependencies

 [[constraint]]
  name = "github.com/stretchr/testify"
-  version = "^1.3.0"
+  version = "^1.1.4"

 [[constraint]]
-  name = "github.com/h2non/gock"
+  name = "github.com/golang/mock"
+  version = "^1.0.0"
+
+[[constraint]]
+  name = "gopkg.in/h2non/gock.v1"
  version = "^1.0.6"
--- a/README.md
+++ b/README.md
@@ -1,16 +1,8 @@
 # Chrly

-[![Written in Go][ico-lang]][link-go]
-[![Build Status][ico-build]][link-build]
-[![Coverage][ico-coverage]][link-coverage]
-[![Keep a Changelog][ico-changelog]](CHANGELOG.md)
-[![Software License][ico-license]](LICENSE)
-[![FOSSA Status][ico-fossa]][link-fossa]
-
-Chrly is a lightweight implementation of Minecraft skins system server with ability to proxy requests to Mojang's
-skins system. It's packaged and distributed as a Docker image and can be downloaded from
-[Dockerhub](https://hub.docker.com/r/elyby/chrly/). App is written in Go, can withstand heavy loads and is
-production ready.
+Chrly is a lightweight implementation of Minecraft skins system server. It's packaged and distributed as a Docker
+image and can be downloaded from [Dockerhub](https://hub.docker.com/r/elyby/chrly/). App is written in Go, can
+withstand heavy loads and is production ready.

 ## Installation

@@ -41,8 +33,7 @@ services:
      - ./data/redis:/data
 ```

-Chrly uses some volumes to persist storage for capes and Redis database. The configuration above mounts them to
-the host machine to do not lose data on container recreations.
+Chrly will mount some volumes on the host machine to persist storage for capes and Redis database.

 ### Config

@@ -58,103 +49,11 @@ docker-compose up -d app

 **Variables to adjust:**

-<table>
-<thead>
-    <tr>
-        <th>ENV</th>
-        <th>Description</th>
-        <th>Example</th>
-    </tr>
-</thead>
-<tbody>
-    <tr>
-        <td>STORAGE_REDIS_HOST</td>
-        <td>
-            By default, Chrly tries to connect to the <code>redis</code> host
-            (by service name in docker-compose configuration).
-        </td>
-        <td><code>localhost</code></td>
-    </tr>
-    <tr>
-        <td>STORAGE_REDIS_PORT</td>
-        <td>
-            Specifies the Redis connection port.
-        </td>
-        <td><code>6379</code></td>
-    </tr>
-    <tr>
-        <td>STORAGE_REDIS_POOL</td>
-        <td>By default, Chrly creates pool with 10 connection, but you may want to increase it</td>
-        <td><code>20</code></td>
-    </tr>
-    <tr>
-        <td>STATSD_ADDR</td>
-        <td>StatsD can be used to collect metrics</td>
-        <td><code>localhost:8125</code></td>
-    </tr>
-    <tr>
-        <td>SENTRY_DSN</td>
-        <td>Sentry can be used to collect app errors</td>
-        <td><code>https://public:private@your.sentry.io/1</code></td>
-    </tr>
-    <tr>
-        <td>QUEUE_LOOP_DELAY</td>
-        <td>
-            Parameter is sets the delay before each iteration of the Mojang's textures queue
-            (<a href="https://golang.org/pkg/time/#ParseDuration">Go's duration</a>)
-        </td>
-        <td><code>3s200ms</code></td>
-    </tr>
-    <tr>
-        <td>QUEUE_BATCH_SIZE</td>
-        <td>
-            Sets the count of usernames, which will be sent to the
-            <a href="https://wiki.vg/Mojang_API#Playernames_-.3E_UUIDs">Mojang's API to exchange them to their UUIDs</a>.
-            The current limit is <code>10</code>, but it may change in the future, so you may want to adjust it.
-        </td>
-        <td><code>10</code></td>
-    </tr>
-    <tr>
-        <td>MOJANG_TEXTURES_ENABLED</td>
-        <td>
-            Allows to completely disable Mojang textures provider for unknown usernames. Enabled by default.
-        </td>
-        <td><code>true</code></td>
-    </tr>
-    <tr>
-        <td id="remote-mojang-uuids-provider">MOJANG_TEXTURES_UUIDS_PROVIDER_DRIVER</td>
-        <td>
-            Specifies the preferred provider of the Mojang's UUIDs. Takes <code>remote</code> value.
-            In any other case, the local queue will be used.
-        </td>
-        <td><code>remote</code></td>
-    </tr>
-    <tr>
-        <td>MOJANG_TEXTURES_UUIDS_PROVIDER_URL</td>
-        <td>
-            When the UUIDs driver set to <code>remote</code>, sets the remote URL.
-            The trailing slash won't cause any problems.
-        </td>
-        <td><code>http://remote-provider.com/api/worker/mojang-uuid</code></td>
-    </tr>
-    <tr>
-        <td>TEXTURES_EXTRA_PARAM_NAME</td>
-        <td>
-            Sets the name of the extra property in the
-            <a href="#get-texturessignedusername">signed textures</a> response.
-        </td>
-        <td><code>your-name</code></td>
-    </tr>
-    <tr>
-        <td>TEXTURES_EXTRA_PARAM_VALUE</td>
-        <td>
-            Sets the value of the extra property in the
-            <a href="#get-texturessignedusername">signed textures</a> response.
-        </td>
-        <td><code>your awesome joke!</code></td>
-    </tr>
-</tbody>
-</table>
+| ENV                | Description                                                                        | Example                                   |
+|--------------------|------------------------------------------------------------------------------------|-------------------------------------------|
+| STORAGE_REDIS_POOL | By default, Chrly creates pool with 10 connection, but you may want to increase it | `20`                                      |
+| STATSD_ADDR        | StatsD can be used to collect metrics                                              | `localhost:8125`                          |
+| SENTRY_DSN         | Sentry can be used to collect app errors                                           | `https://public:private@your.sentry.io/1` |

 If something goes wrong, you can always access logs by executing `docker-compose logs -f app`.

@@ -165,13 +64,13 @@ Each endpoint that accepts `username` as a part of an url takes it case insensit
 #### `GET /skins/{username}.png`

 This endpoint responds to requested `username` with a skin texture. If user's skin was set as texture's link, then it'll
-respond with the `301` redirect to that url. If the skin entry isn't found, it'll request textures information from
-Mojang's API and if it has a skin, than it'll return a `301` redirect to it.
+respond with the `301` redirect to that url. If there is no record for requested username, it'll redirect to the
+Mojang skins system as: `http://skins.minecraft.net/MinecraftSkins/{username}.png` with the original username's case.

 #### `GET /cloaks/{username}.png`

-It responds to requested `username` with a cape texture. If the cape entry isn't found, it'll request textures
-information from Mojang's API and if it has a cape, than it'll return a `301` redirect to it.
+It responds to requested `username` with a cape texture. If user's cape file doesn't exists, then it'll redirect to the
+Mojang skins system as: `http://skins.minecraft.net/MinecraftCloaks/{username}.png` with the original username's case.

 #### `GET /textures/{username}`

@@ -180,19 +79,22 @@ This endpoint forms response payloads as if it was the `textures`' property, but
 ```json
 {
    "SKIN": {
-        "url": "http://example.com/skin.png",
+        "url": "http://ely.by/minecraft/skins/skin.png",
+        "hash": "55d2a8848764f5ff04012cdb093458bd",
        "metadata": {
            "model": "slim"
        }
    },
    "CAPE": {
-        "url": "http://example.com/cape.png"
+        "url": "http://skinsystem.ely.by/cloaks/username",
+        "hash": "424ff79dce9940af89c28ad80de8aaad"
    }
 }
 ```

-If both the skin and the cape entries aren't found, it'll request textures information from Mojang's API and if it has
-a textures property, than it'll return decoded contents.
+If record for the requested username wasn't found, cape would be omitted and skin would be formed for Mojang skins
+system. Hash would be formed as the username plus the half-hour-ranged time of request, which is needed to improve
+caching of Mojang skins inside Minecraft.

 That request is handy in case when your server implements authentication for a game server (e.g. join/hasJoined
 operation) and you have to respond with hasJoined request with an actual user textures. You have to simply send request
@@ -201,8 +103,8 @@ to the Chrly server and put the result in your hasJoined response.
 #### `GET /textures/signed/{username}`

 Actually, it's [Ely.by](http://ely.by) feature called [Server Skins System](http://ely.by/server-skins-system), but if
-you have your own source of Mojang's signatures, then you can pass it with textures and it'll be displayed in response
-of this endpoint. Received response should be directly sent to the client without any modification via game server API.
+you have your own source of the Mojang signatures, then you can pass it with textures and it'll be displayed in this
+method. Received response should be directly sent to the client without any modification via game server API.

 Response example:

@@ -226,10 +128,6 @@ Response example:

 If there is no requested `username` or `mojangSignature` field isn't set, `204` status code will be sent.

-You can adjust URL to `/textures/signed/{username}?proxy=true` to obtain textures information for provided username
-from Mojang's API. The textures will contain unmodified json with addition property with name "chrly" as shown in
-the example above.
-
 #### `GET /skins?name={username}`

 Equivalent of the `GET /skins/{username}.png`, but constructed especially for old Minecraft versions, where username
@@ -266,6 +164,7 @@ form data. `form-urlencoded` also supported, but, as you may know, it doesn't su
 | username        | string | Username. Case insensitive.                                                    |
 | uuid            | uuid   | UUID of the user.                                                              |
 | skinId          | int    | Skin identifier.                                                               |
+| hash            | string | Skin's hash. Algorithm can be any. For example `md5`.                          |
 | is1_8           | bool   | Does the skin have the new format (64x64).                                     |
 | isSlim          | bool   | Does skin have slim arms (Alex model).                                         |
 | mojangTextures  | string | Mojang textures field. It must be a base64 encoded json string. Not required.  |
@@ -308,55 +207,6 @@ response will be:
 }
 ```

-### Worker mode
-
-The worker mode can be used in cooperation with the [remote server mode](#remote-mojang-uuids-provider)
-to exchange Mojang usernames to UUIDs. This mode by itself doesn't solve the problem of
-[extremely strict limits](https://github.com/elyby/chrly/issues/10) on the number of requests to the Mojang's API.
-But with a proxying load balancer (e.g. HAProxy, Nginx, etc.) it's easy to build a cluster of workers,
-which will multiply the bandwidth of the exchanging usernames to its UUIDs.
-
-The instructions for setting up a proxy load balancer are outside the context of this documentation,
-but you get the idea ;)
-
-#### `GET /api/worker/mojang-uuid/{username}`
-
-Performs [batch usernames exchange to UUIDs](https://github.com/elyby/chrly/issues/1) and returns the result in the
-[same format as it returns from the Mojang's API](https://wiki.vg/Mojang_API#Username_-.3E_UUID_at_time):
-
-```json
-{
-    "id": "3e3ee6c35afa48abb61e8cd8c42fc0d9",
-    "name": "ErickSkrauch"
-}
-```
-
-> **Note**: the results aren't cached.
-
-### Health check
-
-#### `GET /healthcheck`
-
-This endpoint can be used to programmatically check the status of the server.
-If all internal checks are successful, the server will return `200` status code with the following body:
-
-```json
-{
-    "status": "OK"
-}
-```
-
-If any of the checks fails, the server will return `503` status code with the following body:
-
-```json
-{
-    "status": "Service Unavailable",
-    "errors": {
-        "mojang-batch-uuids-provider-queue-length": "the maximum number of tasks in the queue has been exceeded"
-    }
-}
-```
-
 ## Development

 First of all you should install the [latest stable version of Go](https://golang.org/doc/install) and set `GOPATH`
@@ -399,20 +249,4 @@ If your Redis instance isn't located at the `localhost`, you can change host by
 `STORAGE_REDIS_HOST`.

 After all of that `go run main.go serve` should successfully start the application.
-To run tests execute `go test ./...`.
-
-## License
-[![FOSSA Status][ico-fossa-big]][link-fossa]
-
-[ico-lang]: https://img.shields.io/badge/lang-go%201.14-blue.svg?style=flat-square
-[ico-build]: https://img.shields.io/travis/elyby/chrly.svg?style=flat-square
-[ico-coverage]: https://img.shields.io/codecov/c/github/elyby/chrly.svg?style=flat-square
-[ico-changelog]: https://img.shields.io/badge/keep%20a-changelog-orange.svg?style=flat-square
-[ico-license]: https://img.shields.io/github/license/elyby/chrly.svg?style=flat-square
-[ico-fossa]: https://app.fossa.io/api/projects/git%2Bgithub.com%2Felyby%2Fchrly.svg?type=shield
-[ico-fossa-big]: https://app.fossa.io/api/projects/git%2Bgithub.com%2Felyby%2Fchrly.svg?type=large
-
-[link-go]: https://golang.org
-[link-build]: https://travis-ci.org/elyby/chrly
-[link-coverage]: https://codecov.io/gh/elyby/chrly
-[link-fossa]: https://app.fossa.io/projects/git%2Bgithub.com%2Felyby%2Fchrly
+To run tests execute `go test ./...`. If your Go version is older than 1.9, then run a `/script/test`.
--- a/api/mojang/mojang.go
+++ b/api/mojang/mojang.go
@@ -1,208 +0,0 @@
-package mojang
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"strings"
-	"time"
-)
-
-var HttpClient = &http.Client{
-	Timeout: 3 * time.Second,
-	Transport: &http.Transport{
-		MaxIdleConnsPerHost: 1024,
-	},
-}
-
-type SignedTexturesResponse struct {
-	Id              string      `json:"id"`
-	Name            string      `json:"name"`
-	Props           []*Property `json:"properties"`
-	decodedTextures *TexturesProp
-}
-
-func (t *SignedTexturesResponse) DecodeTextures() *TexturesProp {
-	if t.decodedTextures == nil {
-		var texturesProp string
-		for _, prop := range t.Props {
-			if prop.Name == "textures" {
-				texturesProp = prop.Value
-				break
-			}
-		}
-
-		if texturesProp == "" {
-			return nil
-		}
-
-		decodedTextures, _ := DecodeTextures(texturesProp)
-		t.decodedTextures = decodedTextures
-	}
-
-	return t.decodedTextures
-}
-
-type Property struct {
-	Name      string `json:"name"`
-	Signature string `json:"signature,omitempty"`
-	Value     string `json:"value"`
-}
-
-type ProfileInfo struct {
-	Id       string `json:"id"`
-	Name     string `json:"name"`
-	IsLegacy bool   `json:"legacy,omitempty"`
-	IsDemo   bool   `json:"demo,omitempty"`
-}
-
-// Exchanges usernames array to array of uuids
-// See https://wiki.vg/Mojang_API#Playernames_-.3E_UUIDs
-func UsernamesToUuids(usernames []string) ([]*ProfileInfo, error) {
-	requestBody, _ := json.Marshal(usernames)
-	request, _ := http.NewRequest("POST", "https://api.mojang.com/profiles/minecraft", bytes.NewBuffer(requestBody))
-
-	request.Header.Set("Content-Type", "application/json")
-
-	response, err := HttpClient.Do(request)
-	if err != nil {
-		return nil, err
-	}
-	defer response.Body.Close()
-
-	if responseErr := validateResponse(response); responseErr != nil {
-		return nil, responseErr
-	}
-
-	var result []*ProfileInfo
-
-	body, _ := ioutil.ReadAll(response.Body)
-	_ = json.Unmarshal(body, &result)
-
-	return result, nil
-}
-
-// Obtains textures information for provided uuid
-// See https://wiki.vg/Mojang_API#UUID_-.3E_Profile_.2B_Skin.2FCape
-func UuidToTextures(uuid string, signed bool) (*SignedTexturesResponse, error) {
-	normalizedUuid := strings.ReplaceAll(uuid, "-", "")
-	url := "https://sessionserver.mojang.com/session/minecraft/profile/" + normalizedUuid
-	if signed {
-		url += "?unsigned=false"
-	}
-
-	request, _ := http.NewRequest("GET", url, nil)
-
-	response, err := HttpClient.Do(request)
-	if err != nil {
-		return nil, err
-	}
-	defer response.Body.Close()
-
-	if responseErr := validateResponse(response); responseErr != nil {
-		return nil, responseErr
-	}
-
-	var result *SignedTexturesResponse
-
-	body, _ := ioutil.ReadAll(response.Body)
-	_ = json.Unmarshal(body, &result)
-
-	return result, nil
-}
-
-func validateResponse(response *http.Response) error {
-	switch {
-	case response.StatusCode == 204:
-		return &EmptyResponse{}
-	case response.StatusCode == 400:
-		type errorResponse struct {
-			Error   string `json:"error"`
-			Message string `json:"errorMessage"`
-		}
-
-		var decodedError *errorResponse
-		body, _ := ioutil.ReadAll(response.Body)
-		_ = json.Unmarshal(body, &decodedError)
-
-		return &BadRequestError{ErrorType: decodedError.Error, Message: decodedError.Message}
-	case response.StatusCode == 403:
-		return &ForbiddenError{}
-	case response.StatusCode == 429:
-		return &TooManyRequestsError{}
-	case response.StatusCode >= 500:
-		return &ServerError{Status: response.StatusCode}
-	}
-
-	return nil
-}
-
-type ResponseError interface {
-	IsMojangError() bool
-}
-
-// Mojang API doesn't return a 404 Not Found error for non-existent data identifiers
-// Instead, they return 204 with an empty body
-type EmptyResponse struct {
-}
-
-func (*EmptyResponse) Error() string {
-	return "200: Empty Response"
-}
-
-func (*EmptyResponse) IsMojangError() bool {
-	return true
-}
-
-// When passed request params are invalid, Mojang returns 400 Bad Request error
-type BadRequestError struct {
-	ResponseError
-	ErrorType string
-	Message   string
-}
-
-func (e *BadRequestError) Error() string {
-	return fmt.Sprintf("400 %s: %s", e.ErrorType, e.Message)
-}
-
-func (*BadRequestError) IsMojangError() bool {
-	return true
-}
-
-// When Mojang decides you're such a bad guy, this error appears (even if the request has no authorization)
-type ForbiddenError struct {
-	ResponseError
-}
-
-func (*ForbiddenError) Error() string {
-	return "403: Forbidden"
-}
-
-// When you exceed the set limit of requests, this error will be returned
-type TooManyRequestsError struct {
-	ResponseError
-}
-
-func (*TooManyRequestsError) Error() string {
-	return "429: Too Many Requests"
-}
-
-func (*TooManyRequestsError) IsMojangError() bool {
-	return true
-}
-
-// ServerError happens when Mojang's API returns any response with 50* status
-type ServerError struct {
-	ResponseError
-	Status int
-}
-
-func (e *ServerError) Error() string {
-	return fmt.Sprintf("%d: %s", e.Status, "Server error")
-}
-
-func (*ServerError) IsMojangError() bool {
-	return true
-}
--- a/api/mojang/mojang_test.go
+++ b/api/mojang/mojang_test.go
@@ -1,310 +0,0 @@
-package mojang
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/h2non/gock"
-	testify "github.com/stretchr/testify/assert"
-)
-
-func TestSignedTexturesResponse(t *testing.T) {
-	t.Run("DecodeTextures", func(t *testing.T) {
-		obj := &SignedTexturesResponse{
-			Id:   "00000000000000000000000000000000",
-			Name: "mock",
-			Props: []*Property{
-				{
-					Name:  "textures",
-					Value: "eyJ0aW1lc3RhbXAiOjE1NTU4NTYzMDc0MTIsInByb2ZpbGVJZCI6IjNlM2VlNmMzNWFmYTQ4YWJiNjFlOGNkOGM0MmZjMGQ5IiwicHJvZmlsZU5hbWUiOiJFcmlja1NrcmF1Y2giLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZmMxNzU3NjMzN2ExMDZkOWMyMmFjNzgyZTM2MmMxNmM0ZTBlNDliZTUzZmFhNDE4NTdiZmYzMzJiNzc5MjgxZSJ9fX0=",
-				},
-			},
-		}
-		textures := obj.DecodeTextures()
-		testify.Equal(t, "3e3ee6c35afa48abb61e8cd8c42fc0d9", textures.ProfileID)
-	})
-
-	t.Run("DecodedTextures without textures prop", func(t *testing.T) {
-		obj := &SignedTexturesResponse{
-			Id:    "00000000000000000000000000000000",
-			Name:  "mock",
-			Props: []*Property{},
-		}
-		textures := obj.DecodeTextures()
-		testify.Nil(t, textures)
-	})
-}
-
-func TestUsernamesToUuids(t *testing.T) {
-	t.Run("exchange usernames to uuids", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://api.mojang.com").
-			Post("/profiles/minecraft").
-			JSON([]string{"Thinkofdeath", "maksimkurb"}).
-			Reply(200).
-			JSON([]map[string]interface{}{
-				{
-					"id":     "4566e69fc90748ee8d71d7ba5aa00d20",
-					"name":   "Thinkofdeath",
-					"legacy": false,
-					"demo":   true,
-				},
-				{
-					"id":   "0d252b7218b648bfb86c2ae476954d32",
-					"name": "maksimkurb",
-					// There is no legacy or demo fields
-				},
-			})
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UsernamesToUuids([]string{"Thinkofdeath", "maksimkurb"})
-		if assert.NoError(err) {
-			assert.Len(result, 2)
-			assert.Equal("4566e69fc90748ee8d71d7ba5aa00d20", result[0].Id)
-			assert.Equal("Thinkofdeath", result[0].Name)
-			assert.False(result[0].IsLegacy)
-			assert.True(result[0].IsDemo)
-
-			assert.Equal("0d252b7218b648bfb86c2ae476954d32", result[1].Id)
-			assert.Equal("maksimkurb", result[1].Name)
-			assert.False(result[1].IsLegacy)
-			assert.False(result[1].IsDemo)
-		}
-	})
-
-	t.Run("handle bad request response", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://api.mojang.com").
-			Post("/profiles/minecraft").
-			Reply(400).
-			JSON(map[string]interface{}{
-				"error":        "IllegalArgumentException",
-				"errorMessage": "profileName can not be null or empty.",
-			})
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UsernamesToUuids([]string{""})
-		assert.Nil(result)
-		assert.IsType(&BadRequestError{}, err)
-		assert.EqualError(err, "400 IllegalArgumentException: profileName can not be null or empty.")
-		assert.Implements((*ResponseError)(nil), err)
-	})
-
-	t.Run("handle forbidden response", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://api.mojang.com").
-			Post("/profiles/minecraft").
-			Reply(403).
-			BodyString("just because")
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UsernamesToUuids([]string{"Thinkofdeath", "maksimkurb"})
-		assert.Nil(result)
-		assert.IsType(&ForbiddenError{}, err)
-		assert.EqualError(err, "403: Forbidden")
-		assert.Implements((*ResponseError)(nil), err)
-	})
-
-	t.Run("handle too many requests response", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://api.mojang.com").
-			Post("/profiles/minecraft").
-			Reply(429).
-			JSON(map[string]interface{}{
-				"error":        "TooManyRequestsException",
-				"errorMessage": "The client has sent too many requests within a certain amount of time",
-			})
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UsernamesToUuids([]string{"Thinkofdeath", "maksimkurb"})
-		assert.Nil(result)
-		assert.IsType(&TooManyRequestsError{}, err)
-		assert.EqualError(err, "429: Too Many Requests")
-		assert.Implements((*ResponseError)(nil), err)
-	})
-
-	t.Run("handle server error", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://api.mojang.com").
-			Post("/profiles/minecraft").
-			Reply(500).
-			BodyString("500 Internal Server Error")
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UsernamesToUuids([]string{"Thinkofdeath", "maksimkurb"})
-		assert.Nil(result)
-		assert.IsType(&ServerError{}, err)
-		assert.EqualError(err, "500: Server error")
-		assert.Equal(500, err.(*ServerError).Status)
-		assert.Implements((*ResponseError)(nil), err)
-	})
-}
-
-func TestUuidToTextures(t *testing.T) {
-	t.Run("obtain not signed textures", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://sessionserver.mojang.com").
-			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
-			Reply(200).
-			JSON(map[string]interface{}{
-				"id":   "4566e69fc90748ee8d71d7ba5aa00d20",
-				"name": "Thinkofdeath",
-				"properties": []interface{}{
-					map[string]interface{}{
-						"name":  "textures",
-						"value": "eyJ0aW1lc3RhbXAiOjE1NDMxMDczMDExODUsInByb2ZpbGVJZCI6IjQ1NjZlNjlmYzkwNzQ4ZWU4ZDcxZDdiYTVhYTAwZDIwIiwicHJvZmlsZU5hbWUiOiJUaGlua29mZGVhdGgiLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNzRkMWUwOGIwYmI3ZTlmNTkwYWYyNzc1ODEyNWJiZWQxNzc4YWM2Y2VmNzI5YWVkZmNiOTYxM2U5OTExYWU3NSJ9LCJDQVBFIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjYzA4ODQwNzAwNDQ3MzIyZDk1M2EwMmI5NjVmMWQ2NWExM2E2MDNiZjY0YjE3YzgwM2MyMTQ0NmZlMTYzNSJ9fX0=",
-					},
-				},
-			})
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UuidToTextures("4566e69fc90748ee8d71d7ba5aa00d20", false)
-		if assert.NoError(err) {
-			assert.Equal("4566e69fc90748ee8d71d7ba5aa00d20", result.Id)
-			assert.Equal("Thinkofdeath", result.Name)
-			assert.Equal(1, len(result.Props))
-			assert.Equal("textures", result.Props[0].Name)
-			assert.Equal(476, len(result.Props[0].Value))
-			assert.Equal("", result.Props[0].Signature)
-		}
-	})
-
-	t.Run("obtain signed textures with dashed uuid", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://sessionserver.mojang.com").
-			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
-			MatchParam("unsigned", "false").
-			Reply(200).
-			JSON(map[string]interface{}{
-				"id":   "4566e69fc90748ee8d71d7ba5aa00d20",
-				"name": "Thinkofdeath",
-				"properties": []interface{}{
-					map[string]interface{}{
-						"name":      "textures",
-						"signature": "signature string",
-						"value":     "eyJ0aW1lc3RhbXAiOjE1NDMxMDczMDExODUsInByb2ZpbGVJZCI6IjQ1NjZlNjlmYzkwNzQ4ZWU4ZDcxZDdiYTVhYTAwZDIwIiwicHJvZmlsZU5hbWUiOiJUaGlua29mZGVhdGgiLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNzRkMWUwOGIwYmI3ZTlmNTkwYWYyNzc1ODEyNWJiZWQxNzc4YWM2Y2VmNzI5YWVkZmNiOTYxM2U5OTExYWU3NSJ9LCJDQVBFIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjYzA4ODQwNzAwNDQ3MzIyZDk1M2EwMmI5NjVmMWQ2NWExM2E2MDNiZjY0YjE3YzgwM2MyMTQ0NmZlMTYzNSJ9fX0=",
-					},
-				},
-			})
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UuidToTextures("4566e69f-c907-48ee-8d71-d7ba5aa00d20", true)
-		if assert.NoError(err) {
-			assert.Equal("4566e69fc90748ee8d71d7ba5aa00d20", result.Id)
-			assert.Equal("Thinkofdeath", result.Name)
-			assert.Equal(1, len(result.Props))
-			assert.Equal("textures", result.Props[0].Name)
-			assert.Equal(476, len(result.Props[0].Value))
-			assert.Equal("signature string", result.Props[0].Signature)
-		}
-	})
-
-	t.Run("handle empty response", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://sessionserver.mojang.com").
-			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
-			Reply(204).
-			BodyString("")
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UuidToTextures("4566e69fc90748ee8d71d7ba5aa00d20", false)
-		assert.Nil(result)
-		assert.IsType(&EmptyResponse{}, err)
-		assert.EqualError(err, "200: Empty Response")
-		assert.Implements((*ResponseError)(nil), err)
-	})
-
-	t.Run("handle too many requests response", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://sessionserver.mojang.com").
-			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
-			Reply(429).
-			JSON(map[string]interface{}{
-				"error":        "TooManyRequestsException",
-				"errorMessage": "The client has sent too many requests within a certain amount of time",
-			})
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UuidToTextures("4566e69fc90748ee8d71d7ba5aa00d20", false)
-		assert.Nil(result)
-		assert.IsType(&TooManyRequestsError{}, err)
-		assert.EqualError(err, "429: Too Many Requests")
-		assert.Implements((*ResponseError)(nil), err)
-	})
-
-	t.Run("handle server error", func(t *testing.T) {
-		assert := testify.New(t)
-
-		defer gock.Off()
-		gock.New("https://sessionserver.mojang.com").
-			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
-			Reply(500).
-			BodyString("500 Internal Server Error")
-
-		client := &http.Client{}
-		gock.InterceptClient(client)
-
-		HttpClient = client
-
-		result, err := UuidToTextures("4566e69fc90748ee8d71d7ba5aa00d20", false)
-		assert.Nil(result)
-		assert.IsType(&ServerError{}, err)
-		assert.EqualError(err, "500: Server error")
-		assert.Equal(500, err.(*ServerError).Status)
-		assert.Implements((*ResponseError)(nil), err)
-	})
-}
--- a/api/mojang/textures.go
+++ b/api/mojang/textures.go
@@ -1,51 +0,0 @@
-package mojang
-
-import (
-	"encoding/base64"
-	"encoding/json"
-)
-
-type TexturesProp struct {
-	Timestamp   int64             `json:"timestamp"`
-	ProfileID   string            `json:"profileId"`
-	ProfileName string            `json:"profileName"`
-	Textures    *TexturesResponse `json:"textures"`
-}
-
-type TexturesResponse struct {
-	Skin *SkinTexturesResponse `json:"SKIN,omitempty"`
-	Cape *CapeTexturesResponse `json:"CAPE,omitempty"`
-}
-
-type SkinTexturesResponse struct {
-	Url      string                `json:"url"`
-	Metadata *SkinTexturesMetadata `json:"metadata,omitempty"`
-}
-
-type SkinTexturesMetadata struct {
-	Model string `json:"model"`
-}
-
-type CapeTexturesResponse struct {
-	Url string `json:"url"`
-}
-
-func DecodeTextures(encodedTextures string) (*TexturesProp, error) {
-	jsonStr, err := base64.URLEncoding.DecodeString(encodedTextures)
-	if err != nil {
-		return nil, err
-	}
-
-	var result *TexturesProp
-	err = json.Unmarshal(jsonStr, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-func EncodeTextures(textures *TexturesProp) string {
-	jsonSerialized, _ := json.Marshal(textures)
-	return base64.URLEncoding.EncodeToString(jsonSerialized)
-}
--- a/api/mojang/textures_test.go
+++ b/api/mojang/textures_test.go
@@ -1,112 +0,0 @@
-package mojang
-
-import (
-	testify "github.com/stretchr/testify/assert"
-	"testing"
-)
-
-type texturesTestCase struct {
-	Name    string
-	Encoded string
-	Decoded *TexturesProp
-}
-
-var texturesTestCases = []*texturesTestCase{
-	{
-		Name:    "property without textures",
-		Encoded: "eyJ0aW1lc3RhbXAiOjE1NTU4NTYwMTA0OTQsInByb2ZpbGVJZCI6IjNlM2VlNmMzNWFmYTQ4YWJiNjFlOGNkOGM0MmZjMGQ5IiwicHJvZmlsZU5hbWUiOiJFcmlja1NrcmF1Y2giLCJ0ZXh0dXJlcyI6e319",
-		Decoded: &TexturesProp{
-			ProfileID:   "3e3ee6c35afa48abb61e8cd8c42fc0d9",
-			ProfileName: "ErickSkrauch",
-			Timestamp:   int64(1555856010494),
-			Textures:    &TexturesResponse{},
-		},
-	},
-	{
-		Name:    "property with classic skin textures",
-		Encoded: "eyJ0aW1lc3RhbXAiOjE1NTU4NTYzMDc0MTIsInByb2ZpbGVJZCI6IjNlM2VlNmMzNWFmYTQ4YWJiNjFlOGNkOGM0MmZjMGQ5IiwicHJvZmlsZU5hbWUiOiJFcmlja1NrcmF1Y2giLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZmMxNzU3NjMzN2ExMDZkOWMyMmFjNzgyZTM2MmMxNmM0ZTBlNDliZTUzZmFhNDE4NTdiZmYzMzJiNzc5MjgxZSJ9fX0=",
-		Decoded: &TexturesProp{
-			ProfileID:   "3e3ee6c35afa48abb61e8cd8c42fc0d9",
-			ProfileName: "ErickSkrauch",
-			Timestamp:   int64(1555856307412),
-			Textures: &TexturesResponse{
-				Skin: &SkinTexturesResponse{
-					Url: "http://textures.minecraft.net/texture/fc17576337a106d9c22ac782e362c16c4e0e49be53faa41857bff332b779281e",
-				},
-			},
-		},
-	},
-	{
-		Name:    "property with alex skin textures",
-		Encoded: "eyJ0aW1lc3RhbXAiOjE1NTU4NTY0OTQ3OTEsInByb2ZpbGVJZCI6IjNlM2VlNmMzNWFmYTQ4YWJiNjFlOGNkOGM0MmZjMGQ5IiwicHJvZmlsZU5hbWUiOiJFcmlja1NrcmF1Y2giLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNjlmNzUzNWY4YzNhMjE1ZDFkZTc3MmIyODdmMTc3M2IzNTg5OGVmNzUyZDI2YmRkZjRhMjVhZGFiNjVjMTg1OSIsIm1ldGFkYXRhIjp7Im1vZGVsIjoic2xpbSJ9fX19",
-		Decoded: &TexturesProp{
-			ProfileID:   "3e3ee6c35afa48abb61e8cd8c42fc0d9",
-			ProfileName: "ErickSkrauch",
-			Timestamp:   int64(1555856494791),
-			Textures: &TexturesResponse{
-				Skin: &SkinTexturesResponse{
-					Url: "http://textures.minecraft.net/texture/69f7535f8c3a215d1de772b287f1773b35898ef752d26bddf4a25adab65c1859",
-					Metadata: &SkinTexturesMetadata{
-						Model: "slim",
-					},
-				},
-			},
-		},
-	},
-	{
-		Name:    "property with skin and cape textures",
-		Encoded: "eyJ0aW1lc3RhbXAiOjE1NTU4NTc2NzUzMzUsInByb2ZpbGVJZCI6ImQ5MGI2OGJjODE3MjQzMjlhMDQ3ZjExODZkY2Q0MzM2IiwicHJvZmlsZU5hbWUiOiJha3Jvbm1hbjEiLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvM2U2ZGVmY2I3ZGU1YTBlMDVjNzUyNWM2Y2Q0NmU0YjliNDE2YjkyZTBjZjRiYWExZTBhOWUyMTJhODg3ZjNmNyJ9LCJDQVBFIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNzBlZmZmYWY4NmZlNWJjMDg5NjA4ZDNjYjI5N2QzZTI3NmI5ZWI3YThmOWYyZmU2NjU5YzIzYTJkOGIxOGVkZiJ9fX0=",
-		Decoded: &TexturesProp{
-			ProfileID:   "d90b68bc81724329a047f1186dcd4336",
-			ProfileName: "akronman1",
-			Timestamp:   int64(1555857675335),
-			Textures: &TexturesResponse{
-				Skin: &SkinTexturesResponse{
-					Url: "http://textures.minecraft.net/texture/3e6defcb7de5a0e05c7525c6cd46e4b9b416b92e0cf4baa1e0a9e212a887f3f7",
-				},
-				Cape: &CapeTexturesResponse{
-					Url: "http://textures.minecraft.net/texture/70efffaf86fe5bc089608d3cb297d3e276b9eb7a8f9f2fe6659c23a2d8b18edf",
-				},
-			},
-		},
-	},
-}
-
-func TestDecodeTextures(t *testing.T) {
-	for _, testCase := range texturesTestCases {
-		t.Run("decode "+testCase.Name, func(t *testing.T) {
-			assert := testify.New(t)
-
-			result, err := DecodeTextures(testCase.Encoded)
-			assert.Nil(err)
-			assert.Equal(testCase.Decoded, result)
-		})
-	}
-
-	t.Run("should return error if invalid base64 passed", func(t *testing.T) {
-		assert := testify.New(t)
-
-		result, err := DecodeTextures("invalid base64")
-		assert.Error(err)
-		assert.Nil(result)
-	})
-
-	t.Run("should return error if invalid json found inside base64", func(t *testing.T) {
-		assert := testify.New(t)
-
-		result, err := DecodeTextures("aW52YWxpZCBqc29u") // encoded "invalid json"
-		assert.Error(err)
-		assert.Nil(result)
-	})
-}
-
-func TestEncodeTextures(t *testing.T) {
-	for _, testCase := range texturesTestCases {
-		t.Run("encode "+testCase.Name, func(t *testing.T) {
-			assert := testify.New(t)
-
-			result := EncodeTextures(testCase.Decoded)
-			assert.Equal(testCase.Encoded, result)
-		})
-	}
-}
--- a/auth/jwt.go
+++ b/auth/jwt.go
@@ -1,4 +1,4 @@
-package http
+package auth

 import (
 	"errors"
@@ -21,7 +21,6 @@ var (
 )

 type JwtAuth struct {
-	Emitter
 	Key []byte
 }

@@ -42,37 +41,42 @@ func (t *JwtAuth) NewToken(scopes ...Scope) ([]byte, error) {
 	return token, nil
 }

-func (t *JwtAuth) Authenticate(req *http.Request) error {
+func (t *JwtAuth) Check(req *http.Request) error {
 	if len(t.Key) == 0 {
-		return t.emitErr(errors.New("Signing key not set"))
+		return &Unauthorized{"Signing key not set"}
 	}

 	bearerToken := req.Header.Get("Authorization")
 	if bearerToken == "" {
-		return t.emitErr(errors.New("Authentication header not presented"))
+		return &Unauthorized{"Authentication header not presented"}
 	}

 	if !strings.EqualFold(bearerToken[0:7], "BEARER ") {
-		return t.emitErr(errors.New("Cannot recognize JWT token in passed value"))
+		return &Unauthorized{"Cannot recognize JWT token in passed value"}
 	}

 	tokenStr := bearerToken[7:]
 	token, err := jws.ParseJWT([]byte(tokenStr))
 	if err != nil {
-		return t.emitErr(errors.New("Cannot parse passed JWT token"))
+		return &Unauthorized{"Cannot parse passed JWT token"}
 	}

 	err = token.Validate(t.Key, hashAlg)
 	if err != nil {
-		return t.emitErr(errors.New("JWT token have invalid signature. It may be corrupted or expired"))
+		return &Unauthorized{"JWT token have invalid signature. It may be corrupted or expired."}
 	}

-	t.Emit("authentication:success")
-
 	return nil
 }

-func (t *JwtAuth) emitErr(err error) error {
-	t.Emit("authentication:error", err)
-	return err
+type Unauthorized struct {
+	Reason string
+}
+
+func (e *Unauthorized) Error() string {
+	if e.Reason != "" {
+		return e.Reason
+	}
+
+	return "Unauthorized"
 }
--- a/auth/jwt_test.go
+++ b/auth/jwt_test.go
@@ -0,0 +1,97 @@
+package auth
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	testify "github.com/stretchr/testify/assert"
+)
+
+const jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxNTE2NjU4MTkzIiwic2NvcGVzIjoic2tpbiJ9.agbBS0qdyYMBaVfTZJAZcTTRgW1Y0kZty4H3N2JHBO8"
+
+func TestJwtAuth_NewToken_Success(t *testing.T) {
+	assert := testify.New(t)
+
+	jwt := &JwtAuth{[]byte("secret")}
+	token, err := jwt.NewToken(SkinScope)
+	assert.Nil(err)
+	assert.NotNil(token)
+}
+
+func TestJwtAuth_NewToken_KeyNotAvailable(t *testing.T) {
+	assert := testify.New(t)
+
+	jwt := &JwtAuth{}
+	token, err := jwt.NewToken(SkinScope)
+	assert.Error(err, "signing key not available")
+	assert.Nil(token)
+}
+
+func TestJwtAuth_Check_EmptyRequest(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	jwt := &JwtAuth{[]byte("secret")}
+
+	err := jwt.Check(req)
+	assert.IsType(&Unauthorized{}, err)
+	assert.EqualError(err, "Authentication header not presented")
+}
+
+func TestJwtAuth_Check_NonBearer(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "this is not jwt")
+	jwt := &JwtAuth{[]byte("secret")}
+
+	err := jwt.Check(req)
+	assert.IsType(&Unauthorized{}, err)
+	assert.EqualError(err, "Cannot recognize JWT token in passed value")
+}
+
+func TestJwtAuth_Check_BearerButNotJwt(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "Bearer thisIs.Not.Jwt")
+	jwt := &JwtAuth{[]byte("secret")}
+
+	err := jwt.Check(req)
+	assert.IsType(&Unauthorized{}, err)
+	assert.EqualError(err, "Cannot parse passed JWT token")
+}
+
+func TestJwtAuth_Check_SecretNotAvailable(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "Bearer " + jwt)
+	jwt := &JwtAuth{}
+
+	err := jwt.Check(req)
+	assert.Error(err, "Signing key not set")
+}
+
+func TestJwtAuth_Check_SecretInvalid(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "Bearer " + jwt)
+	jwt := &JwtAuth{[]byte("this is another secret")}
+
+	err := jwt.Check(req)
+	assert.IsType(&Unauthorized{}, err)
+	assert.EqualError(err, "JWT token have invalid signature. It may be corrupted or expired.")
+}
+
+func TestJwtAuth_Check_Valid(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "Bearer " + jwt)
+	jwt := &JwtAuth{[]byte("secret")}
+
+	err := jwt.Check(req)
+	assert.Nil(err)
+}
--- a/bootstrap/bootstrap.go
+++ b/bootstrap/bootstrap.go
@@ -0,0 +1,64 @@
+package bootstrap
+
+import (
+	"os"
+
+	"github.com/getsentry/raven-go"
+	"github.com/mono83/slf/rays"
+	"github.com/mono83/slf/recievers/sentry"
+	"github.com/mono83/slf/recievers/statsd"
+	"github.com/mono83/slf/recievers/writer"
+	"github.com/mono83/slf/wd"
+)
+
+var version = ""
+
+func GetVersion() string {
+	return version
+}
+
+func CreateLogger(statsdAddr string, sentryAddr string) (wd.Watchdog, error) {
+	wd.AddReceiver(writer.New(writer.Options{
+		Marker: false,
+		TimeFormat: "15:04:05.000",
+	}))
+	if statsdAddr != "" {
+		hostname, _ := os.Hostname()
+		statsdReceiver, err := statsd.NewReceiver(statsd.Config{
+			Address: statsdAddr,
+			Prefix: "ely.skinsystem." + hostname + ".app.",
+			FlushEvery: 1,
+		})
+
+		if err != nil {
+			return nil, err
+		}
+
+		wd.AddReceiver(statsdReceiver)
+	}
+
+	if sentryAddr != "" {
+		ravenClient, err := raven.New(sentryAddr)
+		if err != nil {
+			return nil, err
+		}
+
+		ravenClient.SetEnvironment("production")
+		ravenClient.SetDefaultLoggerName("sentry-watchdog-receiver")
+		programVersion := GetVersion()
+		if programVersion != "" {
+			raven.SetRelease(programVersion)
+		}
+
+		sentryReceiver, err := sentry.NewReceiverWithCustomRaven(ravenClient, &sentry.Config{
+			MinLevel: "warn",
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		wd.AddReceiver(sentryReceiver)
+	}
+
+	return wd.New("", "").WithParams(rays.Host), nil
+}
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -2,23 +2,19 @@ package cmd

 import (
 	"fmt"
-	"log"
 	"os"
 	"strings"

-	. "github.com/goava/di"
+	"github.com/elyby/chrly/bootstrap"
+
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-
-	"github.com/elyby/chrly/di"
-	"github.com/elyby/chrly/http"
-	"github.com/elyby/chrly/version"
 )

 var RootCmd = &cobra.Command{
 	Use:     "chrly",
 	Short:   "Implementation of Minecraft skins system server",
-	Version: version.Version(),
+	Version: bootstrap.GetVersion(),
 }

 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -30,32 +26,6 @@ func Execute() {
 	}
 }

-func shouldGetContainer() *Container {
-	container, err := di.New()
-	if err != nil {
-		panic(err)
-	}
-
-	return container
-}
-
-func startServer(modules []string) {
-	container := shouldGetContainer()
-
-	var config *viper.Viper
-	err := container.Resolve(&config)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	config.Set("modules", modules)
-
-	err = container.Invoke(http.StartServer)
-	if err != nil {
-		log.Fatal(err)
-	}
-}
-
 func init() {
 	cobra.OnInitialize(initConfig)
 }
--- a/cmd/serve.go
+++ b/cmd/serve.go
@@ -1,17 +1,68 @@
 package cmd

 import (
+	"fmt"
+	"log"
+
+	"github.com/elyby/chrly/auth"
+
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/elyby/chrly/bootstrap"
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/http"
 )

 var serveCmd = &cobra.Command{
 	Use:   "serve",
-	Short: "Starts HTTP handler for the skins system",
+	Short: "Starts http handler for the skins system",
 	Run: func(cmd *cobra.Command, args []string) {
-		startServer([]string{"skinsystem", "api"})
+		logger, err := bootstrap.CreateLogger(viper.GetString("statsd.addr"), viper.GetString("sentry.dsn"))
+		if err != nil {
+			log.Fatal(fmt.Printf("Cannot initialize logger: %v", err))
+		}
+		logger.Info("Logger successfully initialized")
+
+		storageFactory := db.StorageFactory{Config: viper.GetViper()}
+
+		logger.Info("Initializing skins repository")
+		skinsRepo, err := storageFactory.CreateFactory("redis").CreateSkinsRepository()
+		if err != nil {
+			logger.Emergency(fmt.Sprintf("Error on creating skins repo: %+v", err))
+			return
+		}
+		logger.Info("Skins repository successfully initialized")
+
+		logger.Info("Initializing capes repository")
+		capesRepo, err := storageFactory.CreateFactory("filesystem").CreateCapesRepository()
+		if err != nil {
+			logger.Emergency(fmt.Sprintf("Error on creating capes repo: %v", err))
+			return
+		}
+		logger.Info("Capes repository successfully initialized")
+
+		cfg := &http.Config{
+			ListenSpec: fmt.Sprintf("%s:%d", viper.GetString("server.host"), viper.GetInt("server.port")),
+			SkinsRepo:  skinsRepo,
+			CapesRepo:  capesRepo,
+			Logger:     logger,
+			Auth:       &auth.JwtAuth{Key: []byte(viper.GetString("chrly.secret"))},
+		}
+
+		if err := cfg.Run(); err != nil {
+			logger.Error(fmt.Sprintf("Error in main(): %v", err))
+		}
 	},
 }

 func init() {
 	RootCmd.AddCommand(serveCmd)
+	viper.SetDefault("server.host", "")
+	viper.SetDefault("server.port", 80)
+	viper.SetDefault("storage.redis.host", "localhost")
+	viper.SetDefault("storage.redis.port", 6379)
+	viper.SetDefault("storage.redis.poll", 10)
+	viper.SetDefault("storage.filesystem.basePath", "data")
+	viper.SetDefault("storage.filesystem.capesDirName", "capes")
 }
--- a/cmd/token.go
+++ b/cmd/token.go
@@ -4,23 +4,18 @@ import (
 	"fmt"
 	"log"

-	"github.com/elyby/chrly/http"
+	"github.com/elyby/chrly/auth"

 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 )

 var tokenCmd = &cobra.Command{
 	Use:   "token",
 	Short: "Creates a new token, which allows to interact with Chrly API",
 	Run: func(cmd *cobra.Command, args []string) {
-		container := shouldGetContainer()
-		var auth *http.JwtAuth
-		err := container.Resolve(&auth)
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		token, err := auth.NewToken(http.SkinScope)
+		jwtAuth := &auth.JwtAuth{Key: []byte(viper.GetString("chrly.secret"))}
+		token, err := jwtAuth.NewToken(auth.SkinScope)
 		if err != nil {
 			log.Fatalf("Unable to create new token. The error is %v\n", err)
 		}
--- a/cmd/version.go
+++ b/cmd/version.go
@@ -2,20 +2,18 @@ package cmd

 import (
 	"fmt"
-	"runtime"

 	"github.com/spf13/cobra"
-
-	"github.com/elyby/chrly/version"
+	"github.com/elyby/chrly/bootstrap"
+	"runtime"
 )

 var versionCmd = &cobra.Command{
 	Use:   "version",
 	Short: "Show the Chrly version information",
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Printf("Version:    %s\n", version.Version())
-		fmt.Printf("Commit:     %s\n", version.Commit())
-		fmt.Printf("Go version: %s\n", runtime.Version())
+		fmt.Printf("Version:    %s\n",    bootstrap.GetVersion())
+		fmt.Printf("Go version: %s\n",    runtime.Version())
 		fmt.Printf("OS/Arch:    %s/%s\n", runtime.GOOS, runtime.GOARCH)
 	},
 }
--- a/cmd/worker.go
+++ b/cmd/worker.go
@@ -1,17 +0,0 @@
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-)
-
-var workerCmd = &cobra.Command{
-	Use:   "worker",
-	Short: "Starts HTTP handler for the Mojang usernames to UUIDs worker",
-	Run: func(cmd *cobra.Command, args []string) {
-		startServer([]string{"worker"})
-	},
-}
-
-func init() {
-	RootCmd.AddCommand(workerCmd)
-}
--- a/db/commons.go
+++ b/db/commons.go
@@ -0,0 +1,25 @@
+package db
+
+type ParamRequired struct {
+	Param string
+}
+
+func (e ParamRequired) Error() string {
+	return "Required parameter not provided"
+}
+
+type SkinNotFoundError struct {
+	Who string
+}
+
+func (e SkinNotFoundError) Error() string {
+	return "Skin data not found."
+}
+
+type CapeNotFoundError struct {
+	Who string
+}
+
+func (e CapeNotFoundError) Error() string {
+	return "Cape file not found."
+}
--- a/db/factory.go
+++ b/db/factory.go
@@ -0,0 +1,34 @@
+package db
+
+import (
+	"github.com/spf13/viper"
+
+	"github.com/elyby/chrly/interfaces"
+)
+
+type StorageFactory struct {
+	Config *viper.Viper
+}
+
+type RepositoriesCreator interface {
+	CreateSkinsRepository() (interfaces.SkinsRepository, error)
+	CreateCapesRepository() (interfaces.CapesRepository, error)
+}
+
+func (factory *StorageFactory) CreateFactory(backend string) RepositoriesCreator {
+	switch backend {
+	case "redis":
+		return &RedisFactory{
+			Host:     factory.Config.GetString("storage.redis.host"),
+			Port:     factory.Config.GetInt("storage.redis.port"),
+			PoolSize: factory.Config.GetInt("storage.redis.poolSize"),
+		}
+	case "filesystem":
+		return &FilesystemFactory{
+			BasePath    : factory.Config.GetString("storage.filesystem.basePath"),
+			CapesDirName: factory.Config.GetString("storage.filesystem.capesDirName"),
+		}
+	}
+
+	return nil
+}
--- a/db/filesystem.go
+++ b/db/filesystem.go
@@ -0,0 +1,59 @@
+package db
+
+import (
+	"os"
+	"path"
+	"strings"
+
+	"github.com/elyby/chrly/interfaces"
+	"github.com/elyby/chrly/model"
+)
+
+type FilesystemFactory struct {
+	BasePath 	 string
+	CapesDirName string
+}
+
+func (f FilesystemFactory) CreateSkinsRepository() (interfaces.SkinsRepository, error) {
+	panic("skins repository not supported for this storage type")
+}
+
+func (f FilesystemFactory) CreateCapesRepository() (interfaces.CapesRepository, error) {
+	if err := f.validateFactoryConfig(); err != nil {
+		return nil, err
+	}
+
+	return &filesStorage{path: path.Join(f.BasePath, f.CapesDirName)}, nil
+}
+
+func (f FilesystemFactory) validateFactoryConfig() error {
+	if f.BasePath == "" {
+		return &ParamRequired{"basePath"}
+	}
+
+	if f.CapesDirName == "" {
+		f.CapesDirName = "capes"
+	}
+
+	return nil
+}
+
+type filesStorage struct {
+	path string
+}
+
+func (repository *filesStorage) FindByUsername(username string) (*model.Cape, error) {
+	if username == "" {
+		return nil, &CapeNotFoundError{username}
+	}
+
+	capePath := path.Join(repository.path, strings.ToLower(username) + ".png")
+	file, err := os.Open(capePath)
+	if err != nil {
+		return nil, &CapeNotFoundError{username}
+	}
+
+	return &model.Cape{
+		File: file,
+	}, nil
+}
--- a/db/fs/fs.go
+++ b/db/fs/fs.go
@@ -1,33 +0,0 @@
-package fs
-
-import (
-	"os"
-	"path"
-	"strings"
-
-	"github.com/elyby/chrly/model"
-)
-
-func New(basePath string) (*Filesystem, error) {
-	return &Filesystem{path: basePath}, nil
-}
-
-type Filesystem struct {
-	path string
-}
-
-func (f *Filesystem) FindCapeByUsername(username string) (*model.Cape, error) {
-	capePath := path.Join(f.path, strings.ToLower(username)+".png")
-	file, err := os.Open(capePath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, nil
-		}
-
-		return nil, err
-	}
-
-	return &model.Cape{
-		File: file,
-	}, nil
-}
--- a/db/fs/fs_integration_test.go
+++ b/db/fs/fs_integration_test.go
@@ -1,56 +0,0 @@
-package fs
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestNew(t *testing.T) {
-	fs, err := New("base/path")
-	require.Nil(t, err)
-	require.Equal(t, "base/path", fs.path)
-}
-
-func TestFilesystem(t *testing.T) {
-	t.Run("FindCapeByUsername", func(t *testing.T) {
-		dir, err := ioutil.TempDir("", "capes")
-		if err != nil {
-			panic(fmt.Errorf("cannot crete temp directory for tests: %w", err))
-		}
-		defer os.RemoveAll(dir)
-
-		t.Run("exists cape", func(t *testing.T) {
-			file, err := os.Create(path.Join(dir, "username.png"))
-			if err != nil {
-				panic(fmt.Errorf("cannot create temp skin for tests: %w", err))
-			}
-			defer os.Remove(file.Name())
-
-			fs, _ := New(dir)
-			cape, err := fs.FindCapeByUsername("username")
-			require.Nil(t, err)
-			require.NotNil(t, cape)
-			capeFile, _ := cape.File.(*os.File)
-			require.Equal(t, file.Name(), capeFile.Name())
-		})
-
-		t.Run("not exists cape", func(t *testing.T) {
-			fs, _ := New(dir)
-			cape, err := fs.FindCapeByUsername("username")
-			require.Nil(t, err)
-			require.Nil(t, cape)
-		})
-
-		t.Run("empty username", func(t *testing.T) {
-			fs, _ := New(dir)
-			cape, err := fs.FindCapeByUsername("")
-			require.Nil(t, err)
-			require.Nil(t, cape)
-		})
-	})
-}
--- a/db/redis.go
+++ b/db/redis.go
@@ -0,0 +1,249 @@
+package db
+
+import (
+	"bytes"
+	"compress/zlib"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/mediocregopher/radix.v2/pool"
+	"github.com/mediocregopher/radix.v2/redis"
+	"github.com/mediocregopher/radix.v2/util"
+
+	"github.com/elyby/chrly/interfaces"
+	"github.com/elyby/chrly/model"
+)
+
+type RedisFactory struct {
+	Host       string
+	Port       int
+	PoolSize   int
+	connection *pool.Pool
+}
+
+// TODO: maybe we should manually return connection to the pool?
+
+func (f RedisFactory) CreateSkinsRepository() (interfaces.SkinsRepository, error) {
+	connection, err := f.getConnection()
+	if err != nil {
+		return nil, err
+	}
+
+	return &redisDb{connection}, nil
+}
+
+func (f RedisFactory) CreateCapesRepository() (interfaces.CapesRepository, error) {
+	panic("capes repository not supported for this storage type")
+}
+
+func (f RedisFactory) getConnection() (*pool.Pool, error) {
+	if f.connection == nil {
+		if f.Host == "" {
+			return nil, &ParamRequired{"host"}
+		}
+
+		if f.Port == 0 {
+			return nil, &ParamRequired{"port"}
+		}
+
+		addr := fmt.Sprintf("%s:%d", f.Host, f.Port)
+		conn, err := pool.New("tcp", addr, f.PoolSize)
+		if err != nil {
+			return nil, err
+		}
+
+		f.connection = conn
+
+		go func() {
+			period := 5
+			for {
+				time.Sleep(time.Duration(period) * time.Second)
+				resp := f.connection.Cmd("PING")
+				if resp.Err == nil {
+					continue
+				}
+
+				log.Println("Redis not pinged. Try to reconnect")
+				conn, err := pool.New("tcp", addr, f.PoolSize)
+				if err != nil {
+					log.Printf("Cannot reconnect to redis: %v\n", err)
+					log.Printf("Waiting %d seconds to retry\n", period)
+					continue
+				}
+
+				f.connection = conn
+				log.Println("Reconnected")
+			}
+		}()
+	}
+
+	return f.connection, nil
+}
+
+type redisDb struct {
+	conn *pool.Pool
+}
+
+const accountIdToUsernameKey = "hash:username-to-account-id"
+
+func (db *redisDb) FindByUsername(username string) (*model.Skin, error) {
+	return findByUsername(username, db.getConn())
+}
+
+func (db *redisDb) FindByUserId(id int) (*model.Skin, error) {
+	return findByUserId(id, db.getConn())
+}
+
+func (db *redisDb) Save(skin *model.Skin) error {
+	return save(skin, db.getConn())
+}
+
+func (db *redisDb) RemoveByUserId(id int) error {
+	return removeByUserId(id, db.getConn())
+}
+
+func (db *redisDb) RemoveByUsername(username string) error {
+	return removeByUsername(username, db.getConn())
+}
+
+func (db *redisDb) getConn() util.Cmder {
+	conn, _ := db.conn.Get()
+	return conn
+}
+
+func findByUsername(username string, conn util.Cmder) (*model.Skin, error) {
+	if username == "" {
+		return nil, &SkinNotFoundError{username}
+	}
+
+	redisKey := buildUsernameKey(username)
+	response := conn.Cmd("GET", redisKey)
+	if response.IsType(redis.Nil) {
+		return nil, &SkinNotFoundError{username}
+	}
+
+	encodedResult, err := response.Bytes()
+	if err != nil {
+		return nil, err
+	}
+
+	result, err := zlibDecode(encodedResult)
+	if err != nil {
+		return nil, err
+	}
+
+	var skin *model.Skin
+	err = json.Unmarshal(result, &skin)
+	if err != nil {
+		return nil, err
+	}
+
+	skin.OldUsername = skin.Username
+
+	return skin, nil
+}
+
+func findByUserId(id int, conn util.Cmder) (*model.Skin, error) {
+	response := conn.Cmd("HGET", accountIdToUsernameKey, id)
+	if response.IsType(redis.Nil) {
+		return nil, &SkinNotFoundError{"unknown"}
+	}
+
+	username, _ := response.Str()
+
+	return findByUsername(username, conn)
+}
+
+func removeByUserId(id int, conn util.Cmder) error {
+	record, err := findByUserId(id, conn)
+	if err != nil {
+		if _, ok := err.(*SkinNotFoundError); !ok {
+			return err
+		}
+	}
+
+	conn.Cmd("MULTI")
+
+	conn.Cmd("HDEL", accountIdToUsernameKey, id)
+	if record != nil {
+		conn.Cmd("DEL", buildUsernameKey(record.Username))
+	}
+
+	conn.Cmd("EXEC")
+
+	return nil
+}
+
+func removeByUsername(username string, conn util.Cmder) error {
+	record, err := findByUsername(username, conn)
+	if err != nil {
+		if _, ok := err.(*SkinNotFoundError); !ok {
+			return err
+		}
+	}
+
+	conn.Cmd("MULTI")
+
+	conn.Cmd("DEL", buildUsernameKey(record.Username))
+	if record != nil {
+		conn.Cmd("HDEL", accountIdToUsernameKey, record.UserId)
+	}
+
+	conn.Cmd("EXEC")
+
+	return nil
+}
+
+func save(skin *model.Skin, conn util.Cmder) error {
+	conn.Cmd("MULTI")
+
+	// If user has changed username, then we must delete his old username record
+	if skin.OldUsername != "" && skin.OldUsername != skin.Username {
+		conn.Cmd("DEL", buildUsernameKey(skin.OldUsername))
+	}
+
+	// If this is a new record or if the user has changed username, we set the value in the hash table
+	if skin.OldUsername != "" || skin.OldUsername != skin.Username {
+		conn.Cmd("HSET", accountIdToUsernameKey, skin.UserId, skin.Username)
+	}
+
+	str, _ := json.Marshal(skin)
+	conn.Cmd("SET", buildUsernameKey(skin.Username), zlibEncode(str))
+
+	conn.Cmd("EXEC")
+
+	skin.OldUsername = skin.Username
+
+	return nil
+}
+
+func buildUsernameKey(username string) string {
+	return "username:" + strings.ToLower(username)
+}
+
+func zlibEncode(str []byte) []byte {
+	var buff bytes.Buffer
+	writer := zlib.NewWriter(&buff)
+	writer.Write(str)
+	writer.Close()
+
+	return buff.Bytes()
+}
+
+func zlibDecode(bts []byte) ([]byte, error) {
+	buff := bytes.NewReader(bts)
+	reader, readError := zlib.NewReader(buff)
+	if readError != nil {
+		return nil, readError
+	}
+
+	resultBuffer := new(bytes.Buffer)
+	io.Copy(resultBuffer, reader)
+	reader.Close()
+
+	return resultBuffer.Bytes(), nil
+}
--- a/db/redis/redis.go
+++ b/db/redis/redis.go
@@ -1,270 +0,0 @@
-package redis
-
-import (
-	"bytes"
-	"compress/zlib"
-	"encoding/json"
-	"io"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/mediocregopher/radix.v2/pool"
-	"github.com/mediocregopher/radix.v2/redis"
-	"github.com/mediocregopher/radix.v2/util"
-
-	"github.com/elyby/chrly/model"
-	"github.com/elyby/chrly/mojangtextures"
-)
-
-var now = time.Now
-
-func New(addr string, poolSize int) (*Redis, error) {
-	conn, err := pool.New("tcp", addr, poolSize)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Redis{
-		pool: conn,
-	}, nil
-}
-
-const accountIdToUsernameKey = "hash:username-to-account-id" // TODO: this should be actually "hash:user-id-to-username"
-const mojangUsernameToUuidKey = "hash:mojang-username-to-uuid"
-
-type Redis struct {
-	pool *pool.Pool
-}
-
-func (db *Redis) FindSkinByUsername(username string) (*model.Skin, error) {
-	conn, err := db.pool.Get()
-	if err != nil {
-		return nil, err
-	}
-	defer db.pool.Put(conn)
-
-	return findByUsername(username, conn)
-}
-
-func findByUsername(username string, conn util.Cmder) (*model.Skin, error) {
-	redisKey := buildUsernameKey(username)
-	response := conn.Cmd("GET", redisKey)
-	if response.IsType(redis.Nil) {
-		return nil, nil
-	}
-
-	encodedResult, _ := response.Bytes()
-	result, err := zlibDecode(encodedResult)
-	if err != nil {
-		return nil, err
-	}
-
-	var skin *model.Skin
-	err = json.Unmarshal(result, &skin)
-	if err != nil {
-		return nil, err
-	}
-
-	skin.OldUsername = skin.Username
-
-	return skin, nil
-}
-
-func (db *Redis) FindSkinByUserId(id int) (*model.Skin, error) {
-	conn, err := db.pool.Get()
-	if err != nil {
-		return nil, err
-	}
-	defer db.pool.Put(conn)
-
-	return findByUserId(id, conn)
-}
-
-func findByUserId(id int, conn util.Cmder) (*model.Skin, error) {
-	response := conn.Cmd("HGET", accountIdToUsernameKey, id)
-	if response.IsType(redis.Nil) {
-		return nil, nil
-	}
-
-	username, err := response.Str()
-	if err != nil {
-		return nil, err
-	}
-
-	return findByUsername(username, conn)
-}
-
-func (db *Redis) SaveSkin(skin *model.Skin) error {
-	conn, err := db.pool.Get()
-	if err != nil {
-		return err
-	}
-	defer db.pool.Put(conn)
-
-	return save(skin, conn)
-}
-
-func save(skin *model.Skin, conn util.Cmder) error {
-	conn.Cmd("MULTI")
-
-	// If user has changed username, then we must delete his old username record
-	if skin.OldUsername != "" && skin.OldUsername != skin.Username {
-		conn.Cmd("DEL", buildUsernameKey(skin.OldUsername))
-	}
-
-	// If this is a new record or if the user has changed username, we set the value in the hash table
-	if skin.OldUsername != "" || skin.OldUsername != skin.Username {
-		conn.Cmd("HSET", accountIdToUsernameKey, skin.UserId, skin.Username)
-	}
-
-	str, _ := json.Marshal(skin)
-	conn.Cmd("SET", buildUsernameKey(skin.Username), zlibEncode(str))
-
-	conn.Cmd("EXEC")
-
-	skin.OldUsername = skin.Username
-
-	return nil
-}
-
-func (db *Redis) RemoveSkinByUserId(id int) error {
-	conn, err := db.pool.Get()
-	if err != nil {
-		return err
-	}
-	defer db.pool.Put(conn)
-
-	return removeByUserId(id, conn)
-}
-
-func removeByUserId(id int, conn util.Cmder) error {
-	record, err := findByUserId(id, conn)
-	if err != nil {
-		return err
-	}
-
-	conn.Cmd("MULTI")
-
-	conn.Cmd("HDEL", accountIdToUsernameKey, id)
-	if record != nil {
-		conn.Cmd("DEL", buildUsernameKey(record.Username))
-	}
-
-	conn.Cmd("EXEC")
-
-	return nil
-}
-
-func (db *Redis) RemoveSkinByUsername(username string) error {
-	conn, err := db.pool.Get()
-	if err != nil {
-		return err
-	}
-	defer db.pool.Put(conn)
-
-	return removeByUsername(username, conn)
-}
-
-func removeByUsername(username string, conn util.Cmder) error {
-	record, err := findByUsername(username, conn)
-	if err != nil {
-		return err
-	}
-
-	if record == nil {
-		return nil
-	}
-
-	conn.Cmd("MULTI")
-
-	conn.Cmd("DEL", buildUsernameKey(record.Username))
-	conn.Cmd("HDEL", accountIdToUsernameKey, record.UserId)
-
-	conn.Cmd("EXEC")
-
-	return nil
-}
-
-func (db *Redis) GetUuid(username string) (string, error) {
-	conn, err := db.pool.Get()
-	if err != nil {
-		return "", err
-	}
-	defer db.pool.Put(conn)
-
-	return findMojangUuidByUsername(username, conn)
-}
-
-func findMojangUuidByUsername(username string, conn util.Cmder) (string, error) {
-	response := conn.Cmd("HGET", mojangUsernameToUuidKey, strings.ToLower(username))
-	if response.IsType(redis.Nil) {
-		return "", &mojangtextures.ValueNotFound{}
-	}
-
-	data, _ := response.Str()
-	parts := strings.Split(data, ":")
-	timestamp, _ := strconv.ParseInt(parts[1], 10, 64)
-	storedAt := time.Unix(timestamp, 0)
-	if storedAt.Add(time.Hour * 24 * 30).Before(now()) {
-		return "", &mojangtextures.ValueNotFound{}
-	}
-
-	return parts[0], nil
-}
-
-func (db *Redis) StoreUuid(username string, uuid string) error {
-	conn, err := db.pool.Get()
-	if err != nil {
-		return err
-	}
-	defer db.pool.Put(conn)
-
-	return storeMojangUuid(username, uuid, conn)
-}
-
-func storeMojangUuid(username string, uuid string, conn util.Cmder) error {
-	value := uuid + ":" + strconv.FormatInt(now().Unix(), 10)
-	res := conn.Cmd("HSET", mojangUsernameToUuidKey, strings.ToLower(username), value)
-	if res.IsType(redis.Err) {
-		return res.Err
-	}
-
-	return nil
-}
-
-func (db *Redis) Ping() error {
-	r := db.pool.Cmd("PING")
-	if r.Err != nil {
-		return r.Err
-	}
-
-	return nil
-}
-
-func buildUsernameKey(username string) string {
-	return "username:" + strings.ToLower(username)
-}
-
-func zlibEncode(str []byte) []byte {
-	var buff bytes.Buffer
-	writer := zlib.NewWriter(&buff)
-	_, _ = writer.Write(str)
-	_ = writer.Close()
-
-	return buff.Bytes()
-}
-
-func zlibDecode(bts []byte) ([]byte, error) {
-	buff := bytes.NewReader(bts)
-	reader, err := zlib.NewReader(buff)
-	if err != nil {
-		return nil, err
-	}
-
-	resultBuffer := new(bytes.Buffer)
-	_, _ = io.Copy(resultBuffer, reader)
-	_ = reader.Close()
-
-	return resultBuffer.Bytes(), nil
-}
--- a/db/redis/redis_integration_test.go
+++ b/db/redis/redis_integration_test.go
@@ -1,361 +0,0 @@
-// +build redis
-
-package redis
-
-import (
-	"fmt"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/mediocregopher/radix.v2/redis"
-	assert "github.com/stretchr/testify/require"
-	"github.com/stretchr/testify/suite"
-
-	"github.com/elyby/chrly/model"
-	"github.com/elyby/chrly/mojangtextures"
-)
-
-const redisAddr = "localhost:6379"
-
-func TestNew(t *testing.T) {
-	t.Run("should connect", func(t *testing.T) {
-		conn, err := New(redisAddr, 12)
-		assert.Nil(t, err)
-		assert.NotNil(t, conn)
-		internalPool := reflect.ValueOf(conn.pool).Elem().FieldByName("pool")
-		assert.Equal(t, 12, internalPool.Cap())
-	})
-
-	t.Run("should return error", func(t *testing.T) {
-		conn, err := New("localhost:12345", 12) // Use localhost to avoid DNS resolution
-		assert.Error(t, err)
-		assert.Nil(t, conn)
-	})
-}
-
-type redisTestSuite struct {
-	suite.Suite
-
-	Redis *Redis
-
-	cmd func(cmd string, args ...interface{}) *redis.Resp
-}
-
-func (suite *redisTestSuite) SetupSuite() {
-	conn, err := New(redisAddr, 10)
-	if err != nil {
-		panic(fmt.Errorf("cannot establish connection to redis: %w", err))
-	}
-
-	suite.Redis = conn
-	suite.cmd = conn.pool.Cmd
-}
-
-func (suite *redisTestSuite) SetupTest() {
-	// Cleanup database before the each test
-	suite.cmd("FLUSHALL")
-}
-
-func (suite *redisTestSuite) TearDownTest() {
-	// Restore time.Now func
-	now = time.Now
-}
-
-func (suite *redisTestSuite) RunSubTest(name string, subTest func()) {
-	suite.SetupTest()
-	suite.Run(name, subTest)
-}
-
-func TestRedis(t *testing.T) {
-	suite.Run(t, new(redisTestSuite))
-}
-
-/**
- * JSON with zlib encoding
- * {
- *     userId: 1,
- *     uuid: "fd5da1e4d66d4d17aadee2446093896d",
- *     username: "Mock",
- *     skinId: 1,
- *     url: "http://localhost/skin.png",
- *     is1_8: true,
- *     isSlim: false,
- *     mojangTextures: "mock-mojang-textures",
- *     mojangSignature: "mock-mojang-signature"
- * }
- */
-var skinRecord = []byte{
-	0x78, 0x9c, 0x5c, 0xce, 0x4b, 0x4a, 0x4, 0x41, 0xc, 0xc6, 0xf1, 0xbb, 0x7c, 0xeb, 0x1a, 0xdb, 0xd6, 0xb2,
-	0x9c, 0xc9, 0xd, 0x5c, 0x88, 0x8b, 0xd1, 0xb5, 0x84, 0x4e, 0xa6, 0xa7, 0xec, 0x7a, 0xc, 0xf5, 0x0, 0x41,
-	0xbc, 0xbb, 0xb4, 0xd2, 0xa, 0x2e, 0xf3, 0xe3, 0x9f, 0x90, 0xf, 0xf4, 0xaa, 0xe5, 0x41, 0x40, 0xa3, 0x41,
-	0xef, 0x5e, 0x40, 0x38, 0xc9, 0x9d, 0xf0, 0xa8, 0x56, 0x9c, 0x13, 0x2b, 0xe3, 0x3d, 0xb3, 0xa8, 0xde, 0x58,
-	0xeb, 0xae, 0xf, 0xb7, 0xfb, 0x83, 0x13, 0x98, 0xef, 0xa5, 0xc4, 0x51, 0x41, 0x78, 0xcc, 0xd3, 0x2, 0x83,
-	0xba, 0xf8, 0xb4, 0x9d, 0x29, 0x1, 0x84, 0x73, 0x6b, 0x17, 0x1a, 0x86, 0x90, 0x27, 0xe, 0xe7, 0x5c, 0xdb,
-	0xb0, 0x16, 0x57, 0x97, 0x34, 0xc3, 0xc0, 0xd7, 0xf1, 0x75, 0xf, 0x6a, 0xa5, 0xeb, 0x3a, 0x1c, 0x83, 0x8f,
-	0xa0, 0x13, 0x87, 0xaa, 0x6, 0x31, 0xbf, 0x71, 0x9a, 0x9f, 0xf5, 0xbd, 0xf5, 0xa2, 0x15, 0x84, 0x98, 0xa7,
-	0x65, 0xf7, 0xa3, 0xbb, 0xb6, 0xf1, 0xd6, 0x1d, 0xfd, 0x9c, 0x78, 0xa5, 0x7f, 0x61, 0xfd, 0x75, 0x83, 0xa7,
-	0x20, 0x2f, 0x7f, 0xff, 0xe2, 0xf3, 0x2b, 0x0, 0x0, 0xff, 0xff, 0x6f, 0xdd, 0x51, 0x71,
-}
-
-func (suite *redisTestSuite) TestFindSkinByUsername() {
-	suite.RunSubTest("exists record", func() {
-		suite.cmd("SET", "username:mock", skinRecord)
-
-		skin, err := suite.Redis.FindSkinByUsername("Mock")
-		suite.Require().Nil(err)
-		suite.Require().NotNil(skin)
-		suite.Require().Equal(1, skin.UserId)
-		suite.Require().Equal("fd5da1e4d66d4d17aadee2446093896d", skin.Uuid)
-		suite.Require().Equal("Mock", skin.Username)
-		suite.Require().Equal(1, skin.SkinId)
-		suite.Require().Equal("http://localhost/skin.png", skin.Url)
-		suite.Require().True(skin.Is1_8)
-		suite.Require().False(skin.IsSlim)
-		suite.Require().Equal("mock-mojang-textures", skin.MojangTextures)
-		suite.Require().Equal("mock-mojang-signature", skin.MojangSignature)
-		suite.Require().Equal(skin.Username, skin.OldUsername)
-	})
-
-	suite.RunSubTest("not exists record", func() {
-		skin, err := suite.Redis.FindSkinByUsername("Mock")
-		suite.Require().Nil(err)
-		suite.Require().Nil(skin)
-	})
-
-	suite.RunSubTest("invalid zlib encoding", func() {
-		suite.cmd("SET", "username:mock", "this is really not zlib")
-		skin, err := suite.Redis.FindSkinByUsername("Mock")
-		suite.Require().Nil(skin)
-		suite.Require().EqualError(err, "zlib: invalid header")
-	})
-
-	suite.RunSubTest("invalid json encoding", func() {
-		suite.cmd("SET", "username:mock", []byte{
-			0x78, 0x9c, 0xca, 0x48, 0xcd, 0xc9, 0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0x1, 0x4, 0x0, 0x0, 0xff,
-			0xff, 0x1a, 0xb, 0x4, 0x5d,
-		})
-		skin, err := suite.Redis.FindSkinByUsername("Mock")
-		suite.Require().Nil(skin)
-		suite.Require().EqualError(err, "invalid character 'h' looking for beginning of value")
-	})
-}
-
-func (suite *redisTestSuite) TestFindSkinByUserId() {
-	suite.RunSubTest("exists record", func() {
-		suite.cmd("SET", "username:mock", skinRecord)
-		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
-
-		skin, err := suite.Redis.FindSkinByUserId(1)
-		suite.Require().Nil(err)
-		suite.Require().NotNil(skin)
-		suite.Require().Equal(1, skin.UserId)
-	})
-
-	suite.RunSubTest("not exists record", func() {
-		skin, err := suite.Redis.FindSkinByUserId(1)
-		suite.Require().Nil(err)
-		suite.Require().Nil(skin)
-	})
-
-	suite.RunSubTest("exists hash record, but no skin record", func() {
-		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
-		skin, err := suite.Redis.FindSkinByUserId(1)
-		suite.Require().Nil(err)
-		suite.Require().Nil(skin)
-	})
-}
-
-func (suite *redisTestSuite) TestSaveSkin() {
-	suite.RunSubTest("save new entity", func() {
-		err := suite.Redis.SaveSkin(&model.Skin{
-			UserId:          1,
-			Uuid:            "fd5da1e4d66d4d17aadee2446093896d",
-			Username:        "Mock",
-			SkinId:          1,
-			Url:             "http://localhost/skin.png",
-			Is1_8:           true,
-			IsSlim:          false,
-			MojangTextures:  "mock-mojang-textures",
-			MojangSignature: "mock-mojang-signature",
-		})
-		suite.Require().Nil(err)
-
-		usernameResp := suite.cmd("GET", "username:mock")
-		suite.Require().False(usernameResp.IsType(redis.Nil))
-		bytes, _ := usernameResp.Bytes()
-		suite.Require().Equal(skinRecord, bytes)
-
-		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
-		suite.Require().False(usernameResp.IsType(redis.Nil))
-		str, _ := idResp.Str()
-		suite.Require().Equal("Mock", str)
-	})
-
-	suite.RunSubTest("save exists record with changed username", func() {
-		suite.cmd("SET", "username:mock", skinRecord)
-		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
-
-		err := suite.Redis.SaveSkin(&model.Skin{
-			UserId:          1,
-			Uuid:            "fd5da1e4d66d4d17aadee2446093896d",
-			Username:        "NewMock",
-			SkinId:          1,
-			Url:             "http://localhost/skin.png",
-			Is1_8:           true,
-			IsSlim:          false,
-			MojangTextures:  "mock-mojang-textures",
-			MojangSignature: "mock-mojang-signature",
-			OldUsername:     "Mock",
-		})
-		suite.Require().Nil(err)
-
-		usernameResp := suite.cmd("GET", "username:newmock")
-		suite.Require().False(usernameResp.IsType(redis.Nil))
-		bytes, _ := usernameResp.Bytes()
-		suite.Require().Equal([]byte{
-			0x78, 0x9c, 0x5c, 0x8e, 0xcb, 0x4e, 0xc3, 0x40, 0xc, 0x45, 0xff, 0xe5, 0xae, 0xa7, 0x84, 0x40, 0x18, 0x5a,
-			0xff, 0x1, 0xb, 0x60, 0x51, 0x58, 0x23, 0x2b, 0x76, 0xd3, 0x21, 0xf3, 0xa8, 0xe6, 0x21, 0x90, 0x10, 0xff,
-			0x8e, 0x52, 0x14, 0x90, 0xba, 0xf4, 0xd1, 0xf1, 0xd5, 0xf9, 0x42, 0x2b, 0x9a, 0x1f, 0x4, 0xd4, 0x1b, 0xb4,
-			0xe6, 0x4, 0x84, 0x83, 0xdc, 0x9, 0xf7, 0x3a, 0x88, 0xb5, 0x32, 0x48, 0x7f, 0xcf, 0x2c, 0xaa, 0x37, 0xc3,
-			0x60, 0xaf, 0x77, 0xb7, 0xdb, 0x9d, 0x15, 0x98, 0xf3, 0x53, 0xe4, 0xa0, 0x20, 0x3c, 0xe9, 0xc7, 0x63, 0x1a,
-			0x67, 0x18, 0x94, 0xd9, 0xc5, 0x75, 0x29, 0x7b, 0x10, 0x8e, 0xb5, 0x9e, 0xa8, 0xeb, 0x7c, 0x1a, 0xd9, 0x1f,
-			0x53, 0xa9, 0xdd, 0x62, 0x5c, 0x9d, 0xe2, 0x4, 0x3, 0x57, 0xfa, 0xb7, 0x2d, 0xa8, 0xe6, 0xa6, 0xcb, 0xb1,
-			0xf7, 0x2e, 0x80, 0xe, 0xec, 0x8b, 0x1a, 0x84, 0xf4, 0xce, 0x71, 0x7a, 0xd1, 0xcf, 0xda, 0xb2, 0x16, 0x10,
-			0x42, 0x1a, 0xe7, 0xcd, 0x2f, 0xdd, 0xd4, 0x15, 0xaf, 0xde, 0xde, 0x4d, 0x91, 0x17, 0x74, 0x21, 0x96, 0x3f,
-			0x6e, 0xf0, 0xec, 0xe5, 0xf5, 0x3f, 0xf9, 0xdc, 0xfb, 0xfd, 0x13, 0x0, 0x0, 0xff, 0xff, 0xca, 0xc3, 0x54,
-			0x25,
-		}, bytes)
-
-		oldUsernameResp := suite.cmd("GET", "username:mock")
-		suite.Require().True(oldUsernameResp.IsType(redis.Nil))
-
-		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
-		suite.Require().False(usernameResp.IsType(redis.Nil))
-		str, _ := idResp.Str()
-		suite.Require().Equal("NewMock", str)
-	})
-}
-
-func (suite *redisTestSuite) TestRemoveSkinByUserId() {
-	suite.RunSubTest("exists record", func() {
-		suite.cmd("SET", "username:mock", skinRecord)
-		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
-
-		err := suite.Redis.RemoveSkinByUserId(1)
-		suite.Require().Nil(err)
-
-		usernameResp := suite.cmd("GET", "username:mock")
-		suite.Require().True(usernameResp.IsType(redis.Nil))
-
-		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
-		suite.Require().True(idResp.IsType(redis.Nil))
-	})
-
-	suite.RunSubTest("exists only id", func() {
-		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
-
-		err := suite.Redis.RemoveSkinByUserId(1)
-		suite.Require().Nil(err)
-
-		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
-		suite.Require().True(idResp.IsType(redis.Nil))
-	})
-
-	suite.RunSubTest("error when querying skin record", func() {
-		suite.cmd("SET", "username:mock", "invalid zlib")
-		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
-
-		err := suite.Redis.RemoveSkinByUserId(1)
-		suite.Require().EqualError(err, "zlib: invalid header")
-	})
-}
-
-func (suite *redisTestSuite) TestRemoveSkinByUsername() {
-	suite.RunSubTest("exists record", func() {
-		suite.cmd("SET", "username:mock", skinRecord)
-		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
-
-		err := suite.Redis.RemoveSkinByUsername("Mock")
-		suite.Require().Nil(err)
-
-		usernameResp := suite.cmd("GET", "username:mock")
-		suite.Require().True(usernameResp.IsType(redis.Nil))
-
-		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
-		suite.Require().True(idResp.IsType(redis.Nil))
-	})
-
-	suite.RunSubTest("exists only username", func() {
-		suite.cmd("SET", "username:mock", skinRecord)
-
-		err := suite.Redis.RemoveSkinByUsername("Mock")
-		suite.Require().Nil(err)
-
-		usernameResp := suite.cmd("GET", "username:mock")
-		suite.Require().True(usernameResp.IsType(redis.Nil))
-	})
-
-	suite.RunSubTest("no records", func() {
-		err := suite.Redis.RemoveSkinByUsername("Mock")
-		suite.Require().Nil(err)
-	})
-
-	suite.RunSubTest("error when querying skin record", func() {
-		suite.cmd("SET", "username:mock", "invalid zlib")
-
-		err := suite.Redis.RemoveSkinByUsername("Mock")
-		suite.Require().EqualError(err, "zlib: invalid header")
-	})
-}
-
-func (suite *redisTestSuite) TestGetUuid() {
-	suite.RunSubTest("exists record", func() {
-		suite.cmd("HSET",
-			"hash:mojang-username-to-uuid",
-			"mock",
-			fmt.Sprintf("%s:%d", "d3ca513eb3e14946b58047f2bd3530fd", time.Now().Unix()),
-		)
-
-		uuid, err := suite.Redis.GetUuid("Mock")
-		suite.Require().Nil(err)
-		suite.Require().Equal("d3ca513eb3e14946b58047f2bd3530fd", uuid)
-	})
-
-	suite.RunSubTest("not exists record", func() {
-		uuid, err := suite.Redis.GetUuid("Mock")
-		suite.Require().Empty(uuid)
-		suite.Require().IsType(new(mojangtextures.ValueNotFound), err)
-	})
-
-	suite.RunSubTest("exists, but expired record", func() {
-		suite.cmd("HSET",
-			"hash:mojang-username-to-uuid",
-			"mock",
-			fmt.Sprintf("%s:%d", "d3ca513eb3e14946b58047f2bd3530fd", time.Now().Add(-1*time.Hour*24*31).Unix()),
-		)
-
-		uuid, err := suite.Redis.GetUuid("Mock")
-		suite.Require().Empty(uuid)
-		suite.Require().IsType(new(mojangtextures.ValueNotFound), err)
-	})
-}
-
-func (suite *redisTestSuite) TestStoreUuid() {
-	now = func() time.Time {
-		return time.Date(2020, 04, 21, 02, 10, 16, 0, time.UTC)
-	}
-
-	err := suite.Redis.StoreUuid("Mock", "d3ca513eb3e14946b58047f2bd3530fd")
-	suite.Require().Nil(err)
-
-	resp := suite.cmd("HGET", "hash:mojang-username-to-uuid", "mock")
-	suite.Require().False(resp.IsType(redis.Nil))
-	str, _ := resp.Str()
-	suite.Require().Equal(str, "d3ca513eb3e14946b58047f2bd3530fd:1587435016")
-}
-
-func (suite *redisTestSuite) TestPing() {
-	err := suite.Redis.Ping()
-	suite.Require().Nil(err)
-}
--- a/di/config.go
+++ b/di/config.go
@@ -1,14 +0,0 @@
-package di
-
-import (
-	"github.com/goava/di"
-	"github.com/spf13/viper"
-)
-
-var config = di.Options(
-	di.Provide(newConfig),
-)
-
-func newConfig() *viper.Viper {
-	return viper.GetViper()
-}
--- a/di/db.go
+++ b/di/db.go
@@ -1,73 +0,0 @@
-package di
-
-import (
-	"fmt"
-	"path"
-
-	"github.com/goava/di"
-	"github.com/spf13/viper"
-
-	"github.com/elyby/chrly/db/fs"
-	"github.com/elyby/chrly/db/redis"
-	es "github.com/elyby/chrly/eventsubscribers"
-	"github.com/elyby/chrly/http"
-	"github.com/elyby/chrly/mojangtextures"
-)
-
-// v4 had the idea that it would be possible to separate backends for storing skins and capes.
-// But in v5 the storage will be unified, so this is just temporary constructors before large reworking.
-//
-// Since there are no options for selecting target backends,
-// all constants in this case point to static specific implementations.
-var db = di.Options(
-	di.Provide(newRedis,
-		di.As(new(http.SkinsRepository)),
-		di.As(new(mojangtextures.UuidsStorage)),
-	),
-	di.Provide(newFSFactory,
-		di.As(new(http.CapesRepository)),
-	),
-	di.Provide(newMojangSignedTexturesStorage),
-)
-
-func newRedis(container *di.Container, config *viper.Viper) (*redis.Redis, error) {
-	config.SetDefault("storage.redis.host", "localhost")
-	config.SetDefault("storage.redis.port", 6379)
-	config.SetDefault("storage.redis.poll", 10)
-
-	conn, err := redis.New(
-		fmt.Sprintf("%s:%d", config.GetString("storage.redis.host"), config.GetInt("storage.redis.port")),
-		config.GetInt("storage.redis.poolSize"),
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := container.Provide(func() *namedHealthChecker {
-		return &namedHealthChecker{
-			Name:    "redis",
-			Checker: es.DatabaseChecker(conn),
-		}
-	}); err != nil {
-		return nil, err
-	}
-
-	return conn, nil
-}
-
-func newFSFactory(config *viper.Viper) (*fs.Filesystem, error) {
-	config.SetDefault("storage.filesystem.basePath", "data")
-	config.SetDefault("storage.filesystem.capesDirName", "capes")
-
-	return fs.New(path.Join(
-		config.GetString("storage.filesystem.basePath"),
-		config.GetString("storage.filesystem.capesDirName"),
-	))
-}
-
-func newMojangSignedTexturesStorage() mojangtextures.TexturesStorage {
-	texturesStorage := mojangtextures.NewInMemoryTexturesStorage()
-	texturesStorage.Start()
-
-	return texturesStorage
-}
--- a/di/di.go
+++ b/di/di.go
@@ -1,20 +0,0 @@
-package di
-
-import "github.com/goava/di"
-
-func New() (*di.Container, error) {
-	container, err := di.New(
-		config,
-		dispatcher,
-		logger,
-		db,
-		mojangTextures,
-		handlers,
-		server,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return container, nil
-}
--- a/di/dispatcher.go
+++ b/di/dispatcher.go
@@ -1,36 +0,0 @@
-package di
-
-import (
-	"github.com/goava/di"
-	"github.com/mono83/slf"
-
-	d "github.com/elyby/chrly/dispatcher"
-	"github.com/elyby/chrly/eventsubscribers"
-	"github.com/elyby/chrly/http"
-	"github.com/elyby/chrly/mojangtextures"
-)
-
-var dispatcher = di.Options(
-	di.Provide(newDispatcher,
-		di.As(new(d.Emitter)),
-		di.As(new(d.Subscriber)),
-		di.As(new(http.Emitter)),
-		di.As(new(mojangtextures.Emitter)),
-		di.As(new(eventsubscribers.Subscriber)),
-	),
-	di.Invoke(enableEventsHandlers),
-)
-
-func newDispatcher() d.Dispatcher {
-	return d.New()
-}
-
-func enableEventsHandlers(
-	dispatcher d.Subscriber,
-	logger slf.Logger,
-	statsReporter slf.StatsReporter,
-) {
-	// TODO: use idea from https://github.com/goava/di/issues/10#issuecomment-615869852
-	(&eventsubscribers.Logger{Logger: logger}).ConfigureWithDispatcher(dispatcher)
-	(&eventsubscribers.StatsReporter{StatsReporter: statsReporter}).ConfigureWithDispatcher(dispatcher)
-}
--- a/di/handlers.go
+++ b/di/handlers.go
@@ -1,151 +0,0 @@
-package di
-
-import (
-	"net/http"
-	"strings"
-
-	"github.com/etherlabsio/healthcheck"
-	"github.com/goava/di"
-	"github.com/gorilla/mux"
-	"github.com/spf13/viper"
-
-	. "github.com/elyby/chrly/http"
-	"github.com/elyby/chrly/mojangtextures"
-)
-
-var handlers = di.Options(
-	di.Provide(newHandlerFactory, di.As(new(http.Handler))),
-	di.Provide(newSkinsystemHandler, di.WithName("skinsystem")),
-	di.Provide(newApiHandler, di.WithName("api")),
-	di.Provide(newUUIDsWorkerHandler, di.WithName("worker")),
-)
-
-func newHandlerFactory(
-	container *di.Container,
-	config *viper.Viper,
-	emitter Emitter,
-) (*mux.Router, error) {
-	enabledModules := config.GetStringSlice("modules")
-
-	// gorilla.mux has no native way to combine multiple routers.
-	// The hack used later in the code works for prefixes in addresses, but leads to misbehavior
-	// if you set an empty prefix. Since the main application should be mounted at the root prefix,
-	// we use it as the base router
-	var router *mux.Router
-	if hasValue(enabledModules, "skinsystem") {
-		if err := container.Resolve(&router, di.Name("skinsystem")); err != nil {
-			return nil, err
-		}
-	} else {
-		router = mux.NewRouter()
-	}
-
-	router.StrictSlash(true)
-	requestEventsMiddleware := CreateRequestEventsMiddleware(emitter, "skinsystem")
-	router.Use(requestEventsMiddleware)
-	// NotFoundHandler doesn't call for registered middlewares, so we must wrap it manually.
-	// See https://github.com/gorilla/mux/issues/416#issuecomment-600079279
-	router.NotFoundHandler = requestEventsMiddleware(http.HandlerFunc(NotFoundHandler))
-
-	// Enable the worker module before api to allow gorilla.mux to correctly find the target router
-	// as it uses the first matching and /api overrides the more accurate /api/worker
-	if hasValue(enabledModules, "worker") {
-		var workerRouter *mux.Router
-		if err := container.Resolve(&workerRouter, di.Name("worker")); err != nil {
-			return nil, err
-		}
-
-		mount(router, "/api/worker", workerRouter)
-	}
-
-	if hasValue(enabledModules, "api") {
-		var apiRouter *mux.Router
-		if err := container.Resolve(&apiRouter, di.Name("api")); err != nil {
-			return nil, err
-		}
-
-		var authenticator Authenticator
-		if err := container.Resolve(&authenticator); err != nil {
-			return nil, err
-		}
-
-		apiRouter.Use(CreateAuthenticationMiddleware(authenticator))
-
-		mount(router, "/api", apiRouter)
-	}
-
-	// Resolve health checkers last, because all the services required by the application
-	// must first be initialized and each of them can publish its own checkers
-	var healthCheckers []*namedHealthChecker
-	if container.Has(&healthCheckers) {
-		if err := container.Resolve(&healthCheckers); err != nil {
-			return nil, err
-		}
-
-		checkersOptions := make([]healthcheck.Option, len(healthCheckers))
-		for i, checker := range healthCheckers {
-			checkersOptions[i] = healthcheck.WithChecker(checker.Name, checker.Checker)
-		}
-
-		router.Handle("/healthcheck", healthcheck.Handler(checkersOptions...)).Methods("GET")
-	}
-
-	return router, nil
-}
-
-func newSkinsystemHandler(
-	config *viper.Viper,
-	emitter Emitter,
-	skinsRepository SkinsRepository,
-	capesRepository CapesRepository,
-	mojangTexturesProvider MojangTexturesProvider,
-) *mux.Router {
-	config.SetDefault("textures.extra_param_name", "chrly")
-	config.SetDefault("textures.extra_param_value", "how do you tame a horse in Minecraft?")
-
-	return (&Skinsystem{
-		Emitter:                 emitter,
-		SkinsRepo:               skinsRepository,
-		CapesRepo:               capesRepository,
-		MojangTexturesProvider:  mojangTexturesProvider,
-		TexturesExtraParamName:  config.GetString("textures.extra_param_name"),
-		TexturesExtraParamValue: config.GetString("textures.extra_param_value"),
-	}).Handler()
-}
-
-func newApiHandler(emitter Emitter, skinsRepository SkinsRepository) *mux.Router {
-	return (&Api{
-		Emitter:   emitter,
-		SkinsRepo: skinsRepository,
-	}).Handler()
-}
-
-func newUUIDsWorkerHandler(mojangUUIDsProvider *mojangtextures.BatchUuidsProvider) *mux.Router {
-	return (&UUIDsWorker{
-		MojangUuidsProvider: mojangUUIDsProvider,
-	}).Handler()
-}
-
-func hasValue(slice []string, needle string) bool {
-	for _, value := range slice {
-		if value == needle {
-			return true
-		}
-	}
-
-	return false
-}
-
-func mount(router *mux.Router, path string, handler http.Handler) {
-	router.PathPrefix(path).Handler(
-		http.StripPrefix(
-			strings.TrimSuffix(path, "/"),
-			handler,
-		),
-	)
-}
-
-type namedHealthChecker struct {
-	Name    string
-	Checker healthcheck.Checker
-}
--- a/di/logger.go
+++ b/di/logger.go
@@ -1,97 +0,0 @@
-package di
-
-import (
-	"os"
-
-	"github.com/getsentry/raven-go"
-	"github.com/goava/di"
-	"github.com/mono83/slf"
-	"github.com/mono83/slf/rays"
-	"github.com/mono83/slf/recievers/sentry"
-	"github.com/mono83/slf/recievers/statsd"
-	"github.com/mono83/slf/recievers/writer"
-	"github.com/mono83/slf/wd"
-	"github.com/spf13/viper"
-
-	"github.com/elyby/chrly/version"
-)
-
-var logger = di.Options(
-	di.Provide(newLogger),
-	di.Provide(newSentry),
-	di.Provide(newStatsReporter),
-)
-
-type loggerParams struct {
-	di.Inject
-
-	SentryRaven *raven.Client `di:"" optional:"true"`
-}
-
-func newLogger(params loggerParams) slf.Logger {
-	dispatcher := &slf.Dispatcher{}
-	dispatcher.AddReceiver(writer.New(writer.Options{
-		Marker:     false,
-		TimeFormat: "15:04:05.000",
-	}))
-
-	if params.SentryRaven != nil {
-		sentryReceiver, _ := sentry.NewReceiverWithCustomRaven(
-			params.SentryRaven,
-			&sentry.Config{
-				MinLevel: "warn",
-			},
-		)
-		dispatcher.AddReceiver(sentryReceiver)
-	}
-
-	logger := wd.Custom("", "", dispatcher)
-	logger.WithParams(rays.Host)
-
-	return logger
-}
-
-func newSentry(config *viper.Viper) (*raven.Client, error) {
-	sentryAddr := config.GetString("sentry.dsn")
-	if sentryAddr == "" {
-		return nil, nil
-	}
-
-	ravenClient, err := raven.New(sentryAddr)
-	if err != nil {
-		return nil, err
-	}
-
-	ravenClient.SetEnvironment("production")
-	ravenClient.SetDefaultLoggerName("sentry-watchdog-receiver")
-	ravenClient.SetRelease(version.Version())
-
-	raven.DefaultClient = ravenClient
-
-	return ravenClient, nil
-}
-
-func newStatsReporter(config *viper.Viper) (slf.StatsReporter, error) {
-	dispatcher := &slf.Dispatcher{}
-
-	statsdAddr := config.GetString("statsd.addr")
-	if statsdAddr != "" {
-		hostname, err := os.Hostname()
-		if err != nil {
-			return nil, err
-		}
-
-		statsdReceiver, err := statsd.NewReceiver(statsd.Config{
-			Address:    statsdAddr,
-			Prefix:     "ely.skinsystem." + hostname + ".app.",
-			FlushEvery: 1,
-		})
-		if err != nil {
-			return nil, err
-		}
-
-		dispatcher.AddReceiver(statsdReceiver)
-	}
-
-	return wd.Custom("", "", dispatcher), nil
-}
--- a/di/mojang_textures.go
+++ b/di/mojang_textures.go
@@ -1,148 +0,0 @@
-package di
-
-import (
-	"fmt"
-	"net/url"
-	"time"
-
-	"github.com/goava/di"
-	"github.com/spf13/viper"
-
-	es "github.com/elyby/chrly/eventsubscribers"
-	"github.com/elyby/chrly/http"
-	"github.com/elyby/chrly/mojangtextures"
-)
-
-var mojangTextures = di.Options(
-	di.Provide(newMojangTexturesProviderFactory),
-	di.Provide(newMojangTexturesProvider),
-	di.Provide(newMojangTexturesUuidsProviderFactory),
-	di.Provide(newMojangTexturesBatchUUIDsProvider),
-	di.Provide(newMojangTexturesRemoteUUIDsProvider),
-	di.Provide(newMojangSignedTexturesProvider),
-	di.Provide(newMojangTexturesStorageFactory),
-)
-
-func newMojangTexturesProviderFactory(
-	container *di.Container,
-	config *viper.Viper,
-) (http.MojangTexturesProvider, error) {
-	config.SetDefault("mojang_textures.enabled", true)
-	if !config.GetBool("mojang_textures.enabled") {
-		return &mojangtextures.NilProvider{}, nil
-	}
-
-	var provider *mojangtextures.Provider
-	err := container.Resolve(&provider)
-	if err != nil {
-		return nil, err
-	}
-
-	return provider, nil
-}
-
-func newMojangTexturesProvider(
-	emitter mojangtextures.Emitter,
-	uuidsProvider mojangtextures.UUIDsProvider,
-	texturesProvider mojangtextures.TexturesProvider,
-	storage mojangtextures.Storage,
-) *mojangtextures.Provider {
-	return &mojangtextures.Provider{
-		Emitter:          emitter,
-		UUIDsProvider:    uuidsProvider,
-		TexturesProvider: texturesProvider,
-		Storage:          storage,
-	}
-}
-
-func newMojangTexturesUuidsProviderFactory(
-	config *viper.Viper,
-	container *di.Container,
-) (mojangtextures.UUIDsProvider, error) {
-	preferredUuidsProvider := config.GetString("mojang_textures.uuids_provider.driver")
-	if preferredUuidsProvider == "remote" {
-		var provider *mojangtextures.RemoteApiUuidsProvider
-		err := container.Resolve(&provider)
-
-		return provider, err
-	}
-
-	var provider *mojangtextures.BatchUuidsProvider
-	err := container.Resolve(&provider)
-
-	return provider, err
-}
-
-func newMojangTexturesBatchUUIDsProvider(
-	container *di.Container,
-	config *viper.Viper,
-	emitter mojangtextures.Emitter,
-) (*mojangtextures.BatchUuidsProvider, error) {
-	if err := container.Provide(func(emitter es.Subscriber, config *viper.Viper) *namedHealthChecker {
-		config.SetDefault("healthcheck.mojang_batch_uuids_provider_cool_down_duration", time.Minute)
-
-		return &namedHealthChecker{
-			Name: "mojang-batch-uuids-provider-response",
-			Checker: es.MojangBatchUuidsProviderResponseChecker(
-				emitter,
-				config.GetDuration("healthcheck.mojang_batch_uuids_provider_cool_down_duration"),
-			),
-		}
-	}); err != nil {
-		return nil, err
-	}
-
-	if err := container.Provide(func(emitter es.Subscriber, config *viper.Viper) *namedHealthChecker {
-		config.SetDefault("healthcheck.mojang_batch_uuids_provider_queue_length_limit", 50)
-
-		return &namedHealthChecker{
-			Name: "mojang-batch-uuids-provider-queue-length",
-			Checker: es.MojangBatchUuidsProviderQueueLengthChecker(
-				emitter,
-				config.GetInt("healthcheck.mojang_batch_uuids_provider_queue_length_limit"),
-			),
-		}
-	}); err != nil {
-		return nil, err
-	}
-
-	config.SetDefault("queue.loop_delay", 2*time.Second+500*time.Millisecond)
-	config.SetDefault("queue.batch_size", 10)
-
-	return &mojangtextures.BatchUuidsProvider{
-		Emitter:        emitter,
-		IterationDelay: config.GetDuration("queue.loop_delay"),
-		IterationSize:  config.GetInt("queue.batch_size"),
-	}, nil
-}
-
-func newMojangTexturesRemoteUUIDsProvider(
-	config *viper.Viper,
-	emitter mojangtextures.Emitter,
-) (*mojangtextures.RemoteApiUuidsProvider, error) {
-	remoteUrl, err := url.Parse(config.GetString("mojang_textures.uuids_provider.url"))
-	if err != nil {
-		return nil, fmt.Errorf("unable to parse remote url: %w", err)
-	}
-
-	return &mojangtextures.RemoteApiUuidsProvider{
-		Emitter: emitter,
-		Url:     *remoteUrl,
-	}, nil
-}
-
-func newMojangSignedTexturesProvider(emitter mojangtextures.Emitter) mojangtextures.TexturesProvider {
-	return &mojangtextures.MojangApiTexturesProvider{
-		Emitter: emitter,
-	}
-}
-
-func newMojangTexturesStorageFactory(
-	uuidsStorage mojangtextures.UuidsStorage,
-	texturesStorage mojangtextures.TexturesStorage,
-) mojangtextures.Storage {
-	return &mojangtextures.SeparatedStorage{
-		UuidsStorage:    uuidsStorage,
-		TexturesStorage: texturesStorage,
-	}
-}
--- a/di/server.go
+++ b/di/server.go
@@ -1,65 +0,0 @@
-package di
-
-import (
-	"errors"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/getsentry/raven-go"
-	"github.com/goava/di"
-	"github.com/spf13/viper"
-
-	. "github.com/elyby/chrly/http"
-)
-
-var server = di.Options(
-	di.Provide(newAuthenticator, di.As(new(Authenticator))),
-	di.Provide(newServer),
-)
-
-func newAuthenticator(config *viper.Viper, emitter Emitter) (*JwtAuth, error) {
-	key := config.GetString("chrly.secret")
-	if key == "" {
-		return nil, errors.New("chrly.secret must be set in order to use authenticator")
-	}
-
-	return &JwtAuth{
-		Key:     []byte(key),
-		Emitter: emitter,
-	}, nil
-}
-
-type serverParams struct {
-	di.Inject
-
-	Config  *viper.Viper  `di:""`
-	Handler http.Handler  `di:""`
-	Sentry  *raven.Client `di:"" optional:"true"`
-}
-
-func newServer(params serverParams) *http.Server {
-	params.Config.SetDefault("server.host", "")
-	params.Config.SetDefault("server.port", 80)
-
-	handler := params.Handler
-	if params.Sentry != nil {
-		// raven.Recoverer uses DefaultClient and nothing can be done about it
-		// To avoid code duplication, if the Sentry service is successfully initiated,
-		// it will also replace DefaultClient, so raven.Recoverer will work with the instance
-		// created in the application constructor
-		handler = raven.Recoverer(handler)
-	}
-
-	address := fmt.Sprintf("%s:%d", params.Config.GetString("server.host"), params.Config.GetInt("server.port"))
-	server := &http.Server{
-		Addr:           address,
-		ReadTimeout:    5 * time.Second,
-		WriteTimeout:   5 * time.Second,
-		IdleTimeout:    60 * time.Second,
-		MaxHeaderBytes: 1 << 16,
-		Handler:        handler,
-	}
-
-	return server
-}
--- a/dispatcher/dispatcher.go
+++ b/dispatcher/dispatcher.go
@@ -1,34 +0,0 @@
-package dispatcher
-
-import "github.com/asaskevich/EventBus"
-
-type Subscriber interface {
-	Subscribe(topic string, fn interface{})
-}
-
-type Emitter interface {
-	Emit(topic string, args ...interface{})
-}
-
-type Dispatcher interface {
-	Subscriber
-	Emitter
-}
-
-type localEventDispatcher struct {
-	bus EventBus.Bus
-}
-
-func (d *localEventDispatcher) Subscribe(topic string, fn interface{}) {
-	_ = d.bus.Subscribe(topic, fn)
-}
-
-func (d *localEventDispatcher) Emit(topic string, args ...interface{}) {
-	d.bus.Publish(topic, args...)
-}
-
-func New() Dispatcher {
-	return &localEventDispatcher{
-		bus: EventBus.New(),
-	}
-}
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -20,15 +20,6 @@ services:
    environment:
      CHRLY_SECRET: replace_this_value_in_production

-  # Use this configuration in case when you need a remote Mojang UUIDs provider
-  # worker:
-  #   image: elyby/chrly
-  #   hostname: chrly0
-  #   restart: always
-  #   ports:
-  #     - "8080:80"
-  #   command: ["worker"]
-
  redis:
    image: redis:4.0-32bit # 32-bit version is recommended to spare some memory
    restart: always
--- a/docker-entrypoint.sh
+++ b/docker-entrypoint.sh
@@ -5,7 +5,7 @@ if [ ! -d /data/capes ]; then
    mkdir -p /data/capes
 fi

-if [ "$1" = "serve" ] || [ "$1" = "worker" ] || [ "$1" = "token" ] || [ "$1" = "version" ]; then
+if [ "$1" = "serve" ] || [ "$1" = "token" ] || [ "$1" = "version" ]; then
    set -- /usr/local/bin/chrly "$@"
 fi

--- a/eventsubscribers/health_checkers.go
+++ b/eventsubscribers/health_checkers.go
@@ -1,84 +0,0 @@
-package eventsubscribers
-
-import (
-	"context"
-	"errors"
-	"sync"
-	"time"
-
-	"github.com/etherlabsio/healthcheck"
-
-	"github.com/elyby/chrly/api/mojang"
-)
-
-type Pingable interface {
-	Ping() error
-}
-
-func DatabaseChecker(connection Pingable) healthcheck.CheckerFunc {
-	return func(ctx context.Context) error {
-		done := make(chan error)
-		go func() {
-			done <- connection.Ping()
-		}()
-
-		select {
-		case <-ctx.Done():
-			return errors.New("check timeout")
-		case err := <-done:
-			return err
-		}
-	}
-}
-
-func MojangBatchUuidsProviderResponseChecker(dispatcher Subscriber, resetDuration time.Duration) healthcheck.CheckerFunc {
-	var mutex sync.Mutex
-	var lastCallErr error
-	var expireTimer *time.Timer
-	dispatcher.Subscribe(
-		"mojang_textures:batch_uuids_provider:result",
-		func(usernames []string, profiles []*mojang.ProfileInfo, err error) {
-			mutex.Lock()
-			defer mutex.Unlock()
-
-			lastCallErr = err
-			if expireTimer != nil {
-				expireTimer.Stop()
-			}
-
-			expireTimer = time.AfterFunc(resetDuration, func() {
-				mutex.Lock()
-				lastCallErr = nil
-				mutex.Unlock()
-			})
-		},
-	)
-
-	return func(ctx context.Context) error {
-		mutex.Lock()
-		defer mutex.Unlock()
-
-		return lastCallErr
-	}
-}
-
-func MojangBatchUuidsProviderQueueLengthChecker(dispatcher Subscriber, maxLength int) healthcheck.CheckerFunc {
-	var mutex sync.Mutex
-	queueLength := 0
-	dispatcher.Subscribe("mojang_textures:batch_uuids_provider:round", func(usernames []string, tasksInQueue int) {
-		mutex.Lock()
-		queueLength = tasksInQueue
-		mutex.Unlock()
-	})
-
-	return func(ctx context.Context) error {
-		mutex.Lock()
-		defer mutex.Unlock()
-
-		if queueLength < maxLength {
-			return nil
-		}
-
-		return errors.New("the maximum number of tasks in the queue has been exceeded")
-	}
-}
--- a/eventsubscribers/health_checkers_test.go
+++ b/eventsubscribers/health_checkers_test.go
@@ -1,109 +0,0 @@
-package eventsubscribers
-
-import (
-	"context"
-	"errors"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-
-	"github.com/elyby/chrly/api/mojang"
-	"github.com/elyby/chrly/dispatcher"
-)
-
-type pingableMock struct {
-	mock.Mock
-}
-
-func (p *pingableMock) Ping() error {
-	args := p.Called()
-	return args.Error(0)
-}
-
-func TestDatabaseChecker(t *testing.T) {
-	t.Run("no error", func(t *testing.T) {
-		p := &pingableMock{}
-		p.On("Ping").Return(nil)
-		checker := DatabaseChecker(p)
-		assert.Nil(t, checker(context.Background()))
-	})
-
-	t.Run("with error", func(t *testing.T) {
-		err := errors.New("mock error")
-		p := &pingableMock{}
-		p.On("Ping").Return(err)
-		checker := DatabaseChecker(p)
-		assert.Equal(t, err, checker(context.Background()))
-	})
-
-	t.Run("context timeout", func(t *testing.T) {
-		p := &pingableMock{}
-		waitChan := make(chan time.Time, 1)
-		p.On("Ping").WaitUntil(waitChan).Return(nil)
-
-		ctx, _ := context.WithTimeout(context.Background(), 0)
-		checker := DatabaseChecker(p)
-		assert.Errorf(t, checker(ctx), "check timeout")
-		close(waitChan)
-	})
-}
-
-func TestMojangBatchUuidsProviderChecker(t *testing.T) {
-	t.Run("empty state", func(t *testing.T) {
-		d := dispatcher.New()
-		checker := MojangBatchUuidsProviderResponseChecker(d, time.Millisecond)
-		assert.Nil(t, checker(context.Background()))
-	})
-	//
-	t.Run("when no error occurred", func(t *testing.T) {
-		d := dispatcher.New()
-		checker := MojangBatchUuidsProviderResponseChecker(d, time.Millisecond)
-		d.Emit("mojang_textures:batch_uuids_provider:result", []string{"username"}, []*mojang.ProfileInfo{}, nil)
-		assert.Nil(t, checker(context.Background()))
-	})
-
-	t.Run("when error occurred", func(t *testing.T) {
-		d := dispatcher.New()
-		checker := MojangBatchUuidsProviderResponseChecker(d, time.Millisecond)
-		err := errors.New("some error occurred")
-		d.Emit("mojang_textures:batch_uuids_provider:result", []string{"username"}, nil, err)
-		assert.Equal(t, err, checker(context.Background()))
-	})
-
-	t.Run("should reset value after passed duration", func(t *testing.T) {
-		d := dispatcher.New()
-		checker := MojangBatchUuidsProviderResponseChecker(d, 20*time.Millisecond)
-		err := errors.New("some error occurred")
-		d.Emit("mojang_textures:batch_uuids_provider:result", []string{"username"}, nil, err)
-		assert.Equal(t, err, checker(context.Background()))
-		time.Sleep(40 * time.Millisecond)
-		assert.Nil(t, checker(context.Background()))
-	})
-}
-
-func TestMojangBatchUuidsProviderQueueLengthChecker(t *testing.T) {
-	t.Run("empty state", func(t *testing.T) {
-		d := dispatcher.New()
-		checker := MojangBatchUuidsProviderQueueLengthChecker(d, 10)
-		assert.Nil(t, checker(context.Background()))
-	})
-
-	t.Run("less than allowed limit", func(t *testing.T) {
-		d := dispatcher.New()
-		checker := MojangBatchUuidsProviderQueueLengthChecker(d, 10)
-		d.Emit("mojang_textures:batch_uuids_provider:round", []string{"username"}, 9)
-		assert.Nil(t, checker(context.Background()))
-	})
-
-	t.Run("greater than allowed limit", func(t *testing.T) {
-		d := dispatcher.New()
-		checker := MojangBatchUuidsProviderQueueLengthChecker(d, 10)
-		d.Emit("mojang_textures:batch_uuids_provider:round", []string{"username"}, 10)
-		checkResult := checker(context.Background())
-		if assert.Error(t, checkResult) {
-			assert.Equal(t, "the maximum number of tasks in the queue has been exceeded", checkResult.Error())
-		}
-	})
-}
--- a/eventsubscribers/logger.go
+++ b/eventsubscribers/logger.go
@@ -1,94 +0,0 @@
-package eventsubscribers
-
-import (
-	"net"
-	"net/http"
-	"net/url"
-	"strings"
-	"syscall"
-
-	"github.com/mono83/slf"
-	"github.com/mono83/slf/wd"
-
-	"github.com/elyby/chrly/api/mojang"
-)
-
-type Logger struct {
-	slf.Logger
-}
-
-func (l *Logger) ConfigureWithDispatcher(d Subscriber) {
-	d.Subscribe("skinsystem:after_request", l.handleAfterSkinsystemRequest)
-
-	d.Subscribe("mojang_textures:usernames:after_call", l.createMojangTexturesErrorHandler("usernames"))
-	d.Subscribe("mojang_textures:textures:after_call", l.createMojangTexturesErrorHandler("textures"))
-}
-
-func (l *Logger) handleAfterSkinsystemRequest(req *http.Request, statusCode int) {
-	path := req.URL.Path
-	if req.URL.RawQuery != "" {
-		path += "?" + req.URL.RawQuery
-	}
-
-	l.Info(
-		":ip - - \":method :path\" :statusCode - \":userAgent\" \":forwardedIp\"",
-		wd.StringParam("ip", trimPort(req.RemoteAddr)),
-		wd.StringParam("method", req.Method),
-		wd.StringParam("path", path),
-		wd.IntParam("statusCode", statusCode),
-		wd.StringParam("userAgent", req.UserAgent()),
-		wd.StringParam("forwardedIp", req.Header.Get("X-Forwarded-For")),
-	)
-}
-
-func (l *Logger) createMojangTexturesErrorHandler(provider string) func(identity string, result interface{}, err error) {
-	providerParam := wd.NameParam(provider)
-	return func(identity string, result interface{}, err error) {
-		if err == nil {
-			return
-		}
-
-		errParam := wd.ErrParam(err)
-
-		switch err.(type) {
-		case *mojang.BadRequestError:
-			l.logMojangTexturesWarning(providerParam, errParam)
-			return
-		case *mojang.ForbiddenError:
-			l.logMojangTexturesWarning(providerParam, errParam)
-			return
-		case *mojang.TooManyRequestsError:
-			l.logMojangTexturesWarning(providerParam, errParam)
-			return
-		case net.Error:
-			if err.(net.Error).Timeout() {
-				return
-			}
-
-			if _, ok := err.(*url.Error); ok {
-				return
-			}
-
-			if opErr, ok := err.(*net.OpError); ok && (opErr.Op == "dial" || opErr.Op == "read") {
-				return
-			}
-
-			if err == syscall.ECONNREFUSED {
-				return
-			}
-		}
-
-		l.Error(":name: Unexpected Mojang response error: :err", providerParam, errParam)
-	}
-}
-
-func (l *Logger) logMojangTexturesWarning(providerParam slf.Param, errParam slf.Param) {
-	l.Warning(":name: :err", providerParam, errParam)
-}
-
-func trimPort(ip string) string {
-	// Don't care about possible -1 result because RemoteAddr will always contain ip and port
-	cutTo := strings.LastIndexByte(ip, ':')
-
-	return ip[0:cutTo]
-}
--- a/eventsubscribers/logger_test.go
+++ b/eventsubscribers/logger_test.go
@@ -1,256 +0,0 @@
-package eventsubscribers
-
-import (
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"syscall"
-	"testing"
-
-	"github.com/mono83/slf"
-	"github.com/mono83/slf/params"
-	"github.com/stretchr/testify/mock"
-
-	"github.com/elyby/chrly/api/mojang"
-	"github.com/elyby/chrly/dispatcher"
-)
-
-type LoggerMock struct {
-	mock.Mock
-}
-
-func prepareLoggerArgs(message string, params []slf.Param) []interface{} {
-	args := []interface{}{message}
-	for _, v := range params {
-		args = append(args, v.(interface{}))
-	}
-
-	return args
-}
-
-func (l *LoggerMock) Trace(message string, params ...slf.Param) {
-	l.Called(prepareLoggerArgs(message, params)...)
-}
-
-func (l *LoggerMock) Debug(message string, params ...slf.Param) {
-	l.Called(prepareLoggerArgs(message, params)...)
-}
-
-func (l *LoggerMock) Info(message string, params ...slf.Param) {
-	l.Called(prepareLoggerArgs(message, params)...)
-}
-
-func (l *LoggerMock) Warning(message string, params ...slf.Param) {
-	l.Called(prepareLoggerArgs(message, params)...)
-}
-
-func (l *LoggerMock) Error(message string, params ...slf.Param) {
-	l.Called(prepareLoggerArgs(message, params)...)
-}
-
-func (l *LoggerMock) Alert(message string, params ...slf.Param) {
-	l.Called(prepareLoggerArgs(message, params)...)
-}
-
-func (l *LoggerMock) Emergency(message string, params ...slf.Param) {
-	l.Called(prepareLoggerArgs(message, params)...)
-}
-
-type LoggerTestCase struct {
-	Events        [][]interface{}
-	ExpectedCalls [][]interface{}
-}
-
-var loggerTestCases = map[string]*LoggerTestCase{
-	"should log each request to the skinsystem": {
-		Events: [][]interface{}{
-			{"skinsystem:after_request",
-				(func() *http.Request {
-					req := httptest.NewRequest("GET", "http://localhost/skins/username.png", nil)
-					req.Header.Add("User-Agent", "Test user agent")
-
-					return req
-				})(),
-				201,
-			},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"Info",
-				":ip - - \":method :path\" :statusCode - \":userAgent\" \":forwardedIp\"",
-				mock.MatchedBy(func(strParam params.String) bool {
-					return strParam.Key == "ip" && strParam.Value == "192.0.2.1"
-				}),
-				mock.MatchedBy(func(strParam params.String) bool {
-					return strParam.Key == "method" && strParam.Value == "GET"
-				}),
-				mock.MatchedBy(func(strParam params.String) bool {
-					return strParam.Key == "path" && strParam.Value == "/skins/username.png"
-				}),
-				mock.MatchedBy(func(strParam params.Int) bool {
-					return strParam.Key == "statusCode" && strParam.Value == 201
-				}),
-				mock.MatchedBy(func(strParam params.String) bool {
-					return strParam.Key == "userAgent" && strParam.Value == "Test user agent"
-				}),
-				mock.MatchedBy(func(strParam params.String) bool {
-					return strParam.Key == "forwardedIp" && strParam.Value == ""
-				}),
-			},
-		},
-	},
-	"should log each request to the skinsystem 2": {
-		Events: [][]interface{}{
-			{"skinsystem:after_request",
-				(func() *http.Request {
-					req := httptest.NewRequest("GET", "http://localhost/skins/username.png?authlib=1.5.2", nil)
-					req.Header.Add("User-Agent", "Test user agent")
-					req.Header.Add("X-Forwarded-For", "1.2.3.4")
-
-					return req
-				})(),
-				201,
-			},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"Info",
-				":ip - - \":method :path\" :statusCode - \":userAgent\" \":forwardedIp\"",
-				mock.Anything, // Already tested
-				mock.Anything, // Already tested
-				mock.MatchedBy(func(strParam params.String) bool {
-					return strParam.Key == "path" && strParam.Value == "/skins/username.png?authlib=1.5.2"
-				}),
-				mock.Anything, // Already tested
-				mock.Anything, // Already tested
-				mock.MatchedBy(func(strParam params.String) bool {
-					return strParam.Key == "forwardedIp" && strParam.Value == "1.2.3.4"
-				}),
-			},
-		},
-	},
-}
-
-type timeoutError struct{}
-
-func (*timeoutError) Error() string   { return "timeout error" }
-func (*timeoutError) Timeout() bool   { return true }
-func (*timeoutError) Temporary() bool { return false }
-
-func init() {
-	// mojang_textures providers errors
-	for _, providerName := range []string{"usernames", "textures"} {
-		pn := providerName // Store pointer to iteration value
-		loggerTestCases["should not log when no error occurred for "+pn+" provider"] = &LoggerTestCase{
-			Events: [][]interface{}{
-				{"mojang_textures:" + pn + ":after_call", pn, &mojang.ProfileInfo{}, nil},
-			},
-			ExpectedCalls: nil,
-		}
-
-		loggerTestCases["should not log when some network errors occured for "+pn+" provider"] = &LoggerTestCase{
-			Events: [][]interface{}{
-				{"mojang_textures:" + pn + ":after_call", pn, nil, &timeoutError{}},
-				{"mojang_textures:" + pn + ":after_call", pn, nil, &url.Error{Op: "GET", URL: "http://localhost"}},
-				{"mojang_textures:" + pn + ":after_call", pn, nil, &net.OpError{Op: "read"}},
-				{"mojang_textures:" + pn + ":after_call", pn, nil, &net.OpError{Op: "dial"}},
-				{"mojang_textures:" + pn + ":after_call", pn, nil, syscall.ECONNREFUSED},
-			},
-			ExpectedCalls: nil,
-		}
-
-		loggerTestCases["should log expected mojang errors for "+pn+" provider"] = &LoggerTestCase{
-			Events: [][]interface{}{
-				{"mojang_textures:" + pn + ":after_call", pn, nil, &mojang.BadRequestError{
-					ErrorType: "IllegalArgumentException",
-					Message:   "profileName can not be null or empty.",
-				}},
-				{"mojang_textures:" + pn + ":after_call", pn, nil, &mojang.ForbiddenError{}},
-				{"mojang_textures:" + pn + ":after_call", pn, nil, &mojang.TooManyRequestsError{}},
-			},
-			ExpectedCalls: [][]interface{}{
-				{"Warning",
-					":name: :err",
-					mock.MatchedBy(func(strParam params.String) bool {
-						return strParam.Key == "name" && strParam.Value == pn
-					}),
-					mock.MatchedBy(func(errParam params.Error) bool {
-						if errParam.Key != "err" {
-							return false
-						}
-
-						if _, ok := errParam.Value.(*mojang.BadRequestError); ok {
-							return true
-						}
-
-						if _, ok := errParam.Value.(*mojang.ForbiddenError); ok {
-							return true
-						}
-
-						if _, ok := errParam.Value.(*mojang.TooManyRequestsError); ok {
-							return true
-						}
-
-						return false
-					}),
-				},
-			},
-		}
-
-		loggerTestCases["should call error when unexpected error occurred for "+pn+" provider"] = &LoggerTestCase{
-			Events: [][]interface{}{
-				{"mojang_textures:" + pn + ":after_call", pn, nil, &mojang.ServerError{Status: 500}},
-			},
-			ExpectedCalls: [][]interface{}{
-				{"Error",
-					":name: Unexpected Mojang response error: :err",
-					mock.MatchedBy(func(strParam params.String) bool {
-						return strParam.Key == "name" && strParam.Value == pn
-					}),
-					mock.MatchedBy(func(errParam params.Error) bool {
-						if errParam.Key != "err" {
-							return false
-						}
-
-						if _, ok := errParam.Value.(*mojang.ServerError); !ok {
-							return false
-						}
-
-						return true
-					}),
-				},
-			},
-		}
-	}
-}
-
-func TestLogger(t *testing.T) {
-	for name, c := range loggerTestCases {
-		t.Run(name, func(t *testing.T) {
-			loggerMock := &LoggerMock{}
-			if c.ExpectedCalls != nil {
-				for _, c := range c.ExpectedCalls {
-					topicName, _ := c[0].(string)
-					loggerMock.On(topicName, c[1:]...)
-				}
-			}
-
-			reporter := &Logger{
-				Logger: loggerMock,
-			}
-
-			d := dispatcher.New()
-			reporter.ConfigureWithDispatcher(d)
-			for _, args := range c.Events {
-				eventName, _ := args[0].(string)
-				d.Emit(eventName, args[1:]...)
-			}
-
-			if c.ExpectedCalls != nil {
-				for _, c := range c.ExpectedCalls {
-					topicName, _ := c[0].(string)
-					loggerMock.AssertCalled(t, topicName, c[1:]...)
-				}
-			}
-		})
-	}
-}
--- a/eventsubscribers/stats_reporter.go
+++ b/eventsubscribers/stats_reporter.go
@@ -1,177 +0,0 @@
-package eventsubscribers
-
-import (
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/mono83/slf"
-
-	"github.com/elyby/chrly/api/mojang"
-)
-
-type StatsReporter struct {
-	slf.StatsReporter
-	Prefix string
-
-	timersMap   map[string]time.Time
-	timersMutex sync.Mutex
-}
-
-func (s *StatsReporter) ConfigureWithDispatcher(d Subscriber) {
-	s.timersMap = make(map[string]time.Time)
-
-	// Per request events
-	d.Subscribe("skinsystem:before_request", s.handleBeforeRequest)
-	d.Subscribe("skinsystem:after_request", s.handleAfterRequest)
-
-	// Authentication events
-	d.Subscribe("authenticator:success", s.incCounterHandler("authentication.challenge")) // TODO: legacy, remove in v5
-	d.Subscribe("authenticator:success", s.incCounterHandler("authentication.success"))
-	d.Subscribe("authentication:error", s.incCounterHandler("authentication.challenge")) // TODO: legacy, remove in v5
-	d.Subscribe("authentication:error", s.incCounterHandler("authentication.failed"))
-
-	// Mojang signed textures source events
-	d.Subscribe("mojang_textures:call", s.incCounterHandler("mojang_textures.request"))
-	d.Subscribe("mojang_textures:usernames:after_cache", func(username string, uuid string, err error) {
-		if err != nil {
-			return
-		}
-
-		if uuid == "" {
-			s.IncCounter("mojang_textures:usernames:cache_hit_nil", 1)
-		} else {
-			s.IncCounter("mojang_textures:usernames:cache_hit", 1)
-		}
-	})
-	d.Subscribe("mojang_textures:textures:after_cache", func(uuid string, textures *mojang.SignedTexturesResponse, err error) {
-		if err != nil {
-			return
-		}
-
-		if textures != nil {
-			s.IncCounter("mojang_textures.textures.cache_hit", 1)
-		}
-	})
-	d.Subscribe("mojang_textures:already_processing", s.incCounterHandler("mojang_textures.already_scheduled"))
-	d.Subscribe("mojang_textures:usernames:after_call", func(username string, profile *mojang.ProfileInfo, err error) {
-		if err != nil {
-			return
-		}
-
-		if profile == nil {
-			s.IncCounter("mojang_textures.usernames.uuid_miss", 1)
-		} else {
-			s.IncCounter("mojang_textures.usernames.uuid_hit", 1)
-		}
-	})
-	d.Subscribe("mojang_textures:textures:before_call", s.incCounterHandler("mojang_textures.textures.request"))
-	d.Subscribe("mojang_textures:textures:after_call", func(uuid string, textures *mojang.SignedTexturesResponse, err error) {
-		if err != nil {
-			return
-		}
-
-		if textures == nil {
-			s.IncCounter("mojang_textures.usernames.textures_miss", 1)
-		} else {
-			s.IncCounter("mojang_textures.usernames.textures_hit", 1)
-		}
-	})
-	d.Subscribe("mojang_textures:before_result", func(username string, uuid string) {
-		s.startTimeRecording("mojang_textures_result_time_" + username)
-	})
-	d.Subscribe("mojang_textures:after_result", func(username string, textures *mojang.SignedTexturesResponse, err error) {
-		s.finalizeTimeRecording("mojang_textures_result_time_"+username, "mojang_textures.result_time")
-	})
-	d.Subscribe("mojang_textures:textures:before_call", func(uuid string) {
-		s.startTimeRecording("mojang_textures_provider_time_" + uuid)
-	})
-	d.Subscribe("mojang_textures:textures:after_call", func(uuid string, textures *mojang.SignedTexturesResponse, err error) {
-		s.finalizeTimeRecording("mojang_textures_provider_time_"+uuid, "mojang_textures.textures.request_time")
-	})
-
-	// Mojang UUIDs batch provider metrics
-	d.Subscribe("mojang_textures:batch_uuids_provider:queued", s.incCounterHandler("mojang_textures.usernames.queued"))
-	d.Subscribe("mojang_textures:batch_uuids_provider:round", func(usernames []string, queueSize int) {
-		s.UpdateGauge("mojang_textures.usernames.iteration_size", int64(len(usernames)))
-		s.UpdateGauge("mojang_textures.usernames.queue_size", int64(queueSize))
-	})
-	d.Subscribe("mojang_textures:batch_uuids_provider:before_round", func() {
-		s.startTimeRecording("batch_uuids_provider_round_time")
-	})
-	d.Subscribe("mojang_textures:batch_uuids_provider:after_round", func() {
-		s.finalizeTimeRecording("batch_uuids_provider_round_time", "mojang_textures.usernames.round_time")
-	})
-}
-
-func (s *StatsReporter) handleBeforeRequest(req *http.Request) {
-	var key string
-	m := req.Method
-	p := req.URL.Path
-	if p == "/skins" {
-		key = "skins.get_request"
-	} else if strings.HasPrefix(p, "/skins/") {
-		key = "skins.request"
-	} else if p == "/cloaks" {
-		key = "capes.get_request"
-	} else if strings.HasPrefix(p, "/cloaks/") {
-		key = "capes.request"
-	} else if strings.HasPrefix(p, "/textures/signed/") {
-		key = "signed_textures.request"
-	} else if strings.HasPrefix(p, "/textures/") {
-		key = "textures.request"
-	} else if m == http.MethodPost && p == "/api/skins" {
-		key = "api.skins.post.request"
-	} else if m == http.MethodDelete && strings.HasPrefix(p, "/api/skins/") {
-		key = "api.skins.delete.request"
-	} else {
-		return
-	}
-
-	s.IncCounter(key, 1)
-}
-
-func (s *StatsReporter) handleAfterRequest(req *http.Request, code int) {
-	var key string
-	m := req.Method
-	p := req.URL.Path
-	if m == http.MethodPost && p == "/api/skins" && code == http.StatusCreated {
-		key = "api.skins.post.success"
-	} else if m == http.MethodPost && p == "/api/skins" && code == http.StatusBadRequest {
-		key = "api.skins.post.validation_failed"
-	} else if m == http.MethodDelete && strings.HasPrefix(p, "/api/skins/") && code == http.StatusNoContent {
-		key = "api.skins.delete.success"
-	} else if m == http.MethodDelete && strings.HasPrefix(p, "/api/skins/") && code == http.StatusNotFound {
-		key = "api.skins.delete.not_found"
-	} else {
-		return
-	}
-
-	s.IncCounter(key, 1)
-}
-
-func (s *StatsReporter) incCounterHandler(name string) func(...interface{}) {
-	return func(...interface{}) {
-		s.IncCounter(name, 1)
-	}
-}
-
-func (s *StatsReporter) startTimeRecording(timeKey string) {
-	s.timersMutex.Lock()
-	defer s.timersMutex.Unlock()
-	s.timersMap[timeKey] = time.Now()
-}
-
-func (s *StatsReporter) finalizeTimeRecording(timeKey string, statName string) {
-	s.timersMutex.Lock()
-	defer s.timersMutex.Unlock()
-	startedAt, ok := s.timersMap[timeKey]
-	if !ok {
-		return
-	}
-
-	delete(s.timersMap, timeKey)
-
-	s.RecordTimer(statName, time.Since(startedAt))
-}
--- a/eventsubscribers/stats_reporter_test.go
+++ b/eventsubscribers/stats_reporter_test.go
@@ -1,383 +0,0 @@
-package eventsubscribers
-
-import (
-	"errors"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/mono83/slf"
-
-	"github.com/elyby/chrly/api/mojang"
-	"github.com/elyby/chrly/dispatcher"
-
-	"github.com/stretchr/testify/mock"
-)
-
-func prepareStatsReporterArgs(name string, value interface{}, params []slf.Param) []interface{} {
-	args := []interface{}{name, value}
-	for _, v := range params {
-		args = append(args, v.(interface{}))
-	}
-
-	return args
-}
-
-type StatsReporterMock struct {
-	mock.Mock
-}
-
-func (r *StatsReporterMock) IncCounter(name string, value int64, params ...slf.Param) {
-	r.Called(prepareStatsReporterArgs(name, value, params)...)
-}
-
-func (r *StatsReporterMock) UpdateGauge(name string, value int64, params ...slf.Param) {
-	r.Called(prepareStatsReporterArgs(name, value, params)...)
-}
-
-func (r *StatsReporterMock) RecordTimer(name string, duration time.Duration, params ...slf.Param) {
-	r.Called(prepareStatsReporterArgs(name, duration, params)...)
-}
-
-func (r *StatsReporterMock) Timer(name string, params ...slf.Param) slf.Timer {
-	return slf.NewTimer(name, params, r)
-}
-
-type StatsReporterTestCase struct {
-	Events        [][]interface{}
-	ExpectedCalls [][]interface{}
-}
-
-var statsReporterTestCases = []*StatsReporterTestCase{
-	// Before request
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/skins/username", nil)},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "skins.request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/skins?name=username", nil)},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "skins.get_request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/cloaks/username", nil)},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "capes.request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/cloaks?name=username", nil)},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "capes.get_request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/textures/username", nil)},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "textures.request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/textures/signed/username", nil)},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "signed_textures.request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("POST", "http://localhost/api/skins", nil)},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "api.skins.post.request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/username", nil)},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "api.skins.delete.request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/id:1", nil)},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "api.skins.delete.request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/unknown", nil)},
-		},
-		ExpectedCalls: nil,
-	},
-	// After request
-	{
-		Events: [][]interface{}{
-			{"skinsystem:after_request", httptest.NewRequest("POST", "http://localhost/api/skins", nil), 201},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "api.skins.post.success", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:after_request", httptest.NewRequest("POST", "http://localhost/api/skins", nil), 400},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "api.skins.post.validation_failed", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/username", nil), 204},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "api.skins.delete.success", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/username", nil), 404},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "api.skins.delete.not_found", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/id:1", nil), 204},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "api.skins.delete.success", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/id:1", nil), 404},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "api.skins.delete.not_found", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/unknown", nil), 404},
-		},
-		ExpectedCalls: nil,
-	},
-	// Authenticator
-	{
-		Events: [][]interface{}{
-			{"authenticator:success"},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "authentication.challenge", int64(1)},
-			{"IncCounter", "authentication.success", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"authentication:error", errors.New("error")},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "authentication.challenge", int64(1)},
-			{"IncCounter", "authentication.failed", int64(1)},
-		},
-	},
-	// Mojang signed textures provider
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:call", "username"},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures.request", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:usernames:after_cache", "username", "", errors.New("error")},
-		},
-		ExpectedCalls: [][]interface{}{},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:usernames:after_cache", "username", "", nil},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures:usernames:cache_hit_nil", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:usernames:after_cache", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures:usernames:cache_hit", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, errors.New("error")},
-		},
-		ExpectedCalls: [][]interface{}{},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, nil},
-		},
-		ExpectedCalls: [][]interface{}{},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", &mojang.SignedTexturesResponse{}, nil},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures.textures.cache_hit", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:already_processing", "username"},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures.already_scheduled", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:usernames:after_call", "username", nil, errors.New("error")},
-		},
-		ExpectedCalls: [][]interface{}{},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:usernames:after_call", "username", nil, nil},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures.usernames.uuid_miss", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:usernames:after_call", "username", &mojang.ProfileInfo{}, nil},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures.usernames.uuid_hit", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, errors.New("error")},
-		},
-		ExpectedCalls: [][]interface{}{},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, nil},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures.usernames.textures_miss", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", &mojang.SignedTexturesResponse{}, nil},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures.usernames.textures_hit", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:before_result", "username", ""},
-			{"mojang_textures:after_result", "username", &mojang.SignedTexturesResponse{}, nil},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"RecordTimer", "mojang_textures.result_time", mock.AnythingOfType("time.Duration")},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:textures:before_call", "аааааааааааааааааааааааааааааааа"},
-			{"mojang_textures:textures:after_call", "аааааааааааааааааааааааааааааааа", &mojang.SignedTexturesResponse{}, nil},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures.textures.request", int64(1)},
-			{"IncCounter", "mojang_textures.usernames.textures_hit", int64(1)},
-			{"RecordTimer", "mojang_textures.textures.request_time", mock.AnythingOfType("time.Duration")},
-		},
-	},
-	// Batch UUIDs provider
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:batch_uuids_provider:queued", "username"},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"IncCounter", "mojang_textures.usernames.queued", int64(1)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:batch_uuids_provider:round", []string{"username1", "username2"}, 5},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"UpdateGauge", "mojang_textures.usernames.iteration_size", int64(2)},
-			{"UpdateGauge", "mojang_textures.usernames.queue_size", int64(5)},
-		},
-	},
-	{
-		Events: [][]interface{}{
-			{"mojang_textures:batch_uuids_provider:before_round"},
-			{"mojang_textures:batch_uuids_provider:after_round"},
-		},
-		ExpectedCalls: [][]interface{}{
-			{"RecordTimer", "mojang_textures.usernames.round_time", mock.AnythingOfType("time.Duration")},
-		},
-	},
-}
-
-func TestStatsReporter(t *testing.T) {
-	for _, c := range statsReporterTestCases {
-		t.Run("handle events", func(t *testing.T) {
-			statsReporterMock := &StatsReporterMock{}
-			if c.ExpectedCalls != nil {
-				for _, c := range c.ExpectedCalls {
-					topicName, _ := c[0].(string)
-					statsReporterMock.On(topicName, c[1:]...).Once()
-				}
-			}
-
-			reporter := &StatsReporter{
-				StatsReporter: statsReporterMock,
-				Prefix:        "mock_prefix",
-			}
-
-			d := dispatcher.New()
-			reporter.ConfigureWithDispatcher(d)
-			for _, e := range c.Events {
-				eventName, _ := e[0].(string)
-				d.Emit(eventName, e[1:]...)
-			}
-
-			statsReporterMock.AssertExpectations(t)
-		})
-	}
-}
--- a/eventsubscribers/subscriber.go
+++ b/eventsubscribers/subscriber.go
@@ -1,7 +0,0 @@
-package eventsubscribers
-
-import "github.com/elyby/chrly/dispatcher"
-
-type Subscriber interface {
-	dispatcher.Subscriber
-}
--- a/http/api.go
+++ b/http/api.go
@@ -1,38 +1,29 @@
 package http

 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
 	"regexp"
 	"strconv"

-	"github.com/gorilla/mux"
-	"github.com/thedevsaddam/govalidator"
-
+	"github.com/elyby/chrly/auth"
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/interfaces"
 	"github.com/elyby/chrly/model"
+
+	"github.com/gorilla/mux"
+	"github.com/mono83/slf/wd"
+	"github.com/thedevsaddam/govalidator"
 )

-//noinspection GoSnakeCaseUsage
-const UUID_ANY = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
-
-var regexUuidAny = regexp.MustCompile(UUID_ANY)
-
 func init() {
-	govalidator.AddCustomRule("skinUploadingNotAvailable", func(field string, rule string, message string, value interface{}) error {
-		if message == "" {
-			message = "Skin uploading is temporary unavailable"
-		}
-
-		return errors.New(message)
-	})
-
-	// Add ability to validate any possible uuid form
-	govalidator.AddCustomRule("uuid_any", func(field string, rule string, message string, value interface{}) error {
-		str := value.(string)
-		if !regexUuidAny.MatchString(str) {
+	govalidator.AddCustomRule("md5", func(field string, rule string, message string, value interface{}) error {
+		val := []byte(value.(string))
+		if ok, _ := regexp.Match(`^[a-f0-9]{32}$`, val); !ok {
 			if message == "" {
-				message = fmt.Sprintf("The %s field must contain valid UUID", field)
+				message = fmt.Sprintf("The %s field must be a valid md5 hash", field)
 			}

 			return errors.New(message)
@@ -40,25 +31,21 @@ func init() {

 		return nil
 	})
+
+	govalidator.AddCustomRule("skinUploadingNotAvailable", func(field string, rule string, message string, value interface{}) error {
+		if message == "" {
+			message = "Skin uploading is temporary unavailable"
+		}
+
+		return errors.New(message)
+	})
 }

-type Api struct {
-	Emitter
-	SkinsRepo SkinsRepository
-}
-
-func (ctx *Api) Handler() *mux.Router {
-	router := mux.NewRouter().StrictSlash(true)
-	router.HandleFunc("/skins", ctx.postSkinHandler).Methods(http.MethodPost)
-	router.HandleFunc("/skins/id:{id:[0-9]+}", ctx.deleteSkinByUserIdHandler).Methods(http.MethodDelete)
-	router.HandleFunc("/skins/{username}", ctx.deleteSkinByUsernameHandler).Methods(http.MethodDelete)
-
-	return router
-}
-
-func (ctx *Api) postSkinHandler(resp http.ResponseWriter, req *http.Request) {
+func (cfg *Config) PostSkin(resp http.ResponseWriter, req *http.Request) {
+	cfg.Logger.IncCounter("api.skins.post.request", 1)
 	validationErrors := validatePostSkinRequest(req)
 	if validationErrors != nil {
+		cfg.Logger.IncCounter("api.skins.post.validation_failed", 1)
 		apiBadRequest(resp, validationErrors)
 		return
 	}
@@ -66,124 +53,110 @@ func (ctx *Api) postSkinHandler(resp http.ResponseWriter, req *http.Request) {
 	identityId, _ := strconv.Atoi(req.Form.Get("identityId"))
 	username := req.Form.Get("username")

-	record, err := ctx.findIdentityOrCleanup(identityId, username)
+	record, err := findIdentity(cfg.SkinsRepo, identityId, username)
 	if err != nil {
-		ctx.Emit("skinsystem:error", fmt.Errorf("error on requesting a skin from the repository: %w", err))
+		cfg.Logger.Error("Error on requesting a skin from the repository: :err", wd.ErrParam(err))
 		apiServerError(resp)
 		return
 	}

-	if record == nil {
-		record = &model.Skin{
-			UserId:   identityId,
-			Username: username,
-		}
-	}
-
 	skinId, _ := strconv.Atoi(req.Form.Get("skinId"))
 	is18, _ := strconv.ParseBool(req.Form.Get("is1_8"))
 	isSlim, _ := strconv.ParseBool(req.Form.Get("isSlim"))

 	record.Uuid = req.Form.Get("uuid")
 	record.SkinId = skinId
+	record.Hash = req.Form.Get("hash")
 	record.Is1_8 = is18
 	record.IsSlim = isSlim
 	record.Url = req.Form.Get("url")
 	record.MojangTextures = req.Form.Get("mojangTextures")
 	record.MojangSignature = req.Form.Get("mojangSignature")

-	err = ctx.SkinsRepo.SaveSkin(record)
+	err = cfg.SkinsRepo.Save(record)
 	if err != nil {
-		ctx.Emit("skinsystem:error", fmt.Errorf("unable to save record to the repository: %w", err))
+		cfg.Logger.Error("Unable to save record to the repository: :err", wd.ErrParam(err))
 		apiServerError(resp)
 		return
 	}

+	cfg.Logger.IncCounter("api.skins.post.success", 1)
 	resp.WriteHeader(http.StatusCreated)
 }

-func (ctx *Api) deleteSkinByUserIdHandler(resp http.ResponseWriter, req *http.Request) {
+func (cfg *Config) DeleteSkinByUserId(resp http.ResponseWriter, req *http.Request) {
+	cfg.Logger.IncCounter("api.skins.delete.request", 1)
 	id, _ := strconv.Atoi(mux.Vars(req)["id"])
-	skin, err := ctx.SkinsRepo.FindSkinByUserId(id)
-	ctx.deleteSkin(skin, err, resp)
+	skin, err := cfg.SkinsRepo.FindByUserId(id)
+	if err != nil {
+		cfg.Logger.IncCounter("api.skins.delete.not_found", 1)
+		apiNotFound(resp, "Cannot find record for requested user id")
+		return
+	}
+
+	cfg.deleteSkin(skin, resp)
 }

-func (ctx *Api) deleteSkinByUsernameHandler(resp http.ResponseWriter, req *http.Request) {
+func (cfg *Config) DeleteSkinByUsername(resp http.ResponseWriter, req *http.Request) {
+	cfg.Logger.IncCounter("api.skins.delete.request", 1)
 	username := mux.Vars(req)["username"]
-	skin, err := ctx.SkinsRepo.FindSkinByUsername(username)
-	ctx.deleteSkin(skin, err, resp)
+	skin, err := cfg.SkinsRepo.FindByUsername(username)
+	if err != nil {
+		cfg.Logger.IncCounter("api.skins.delete.not_found", 1)
+		apiNotFound(resp, "Cannot find record for requested username")
+		return
+	}
+
+	cfg.deleteSkin(skin, resp)
 }

-func (ctx *Api) deleteSkin(skin *model.Skin, err error, resp http.ResponseWriter) {
-	if err != nil {
-		ctx.Emit("skinsystem:error", fmt.Errorf("unable to find skin info from the repository: %w", err))
-		apiServerError(resp)
-		return
-	}
+func (cfg *Config) Authenticate(handler http.Handler) http.Handler {
+	return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+		cfg.Logger.IncCounter("authentication.challenge", 1)
+		err := cfg.Auth.Check(req)
+		if err != nil {
+			if _, ok := err.(*auth.Unauthorized); ok {
+				cfg.Logger.IncCounter("authentication.failed", 1)
+				apiForbidden(resp, err.Error())
+			} else {
+				cfg.Logger.Error("Unknown error on validating api request: :err", wd.ErrParam(err))
+				apiServerError(resp)
+			}

-	if skin == nil {
-		apiNotFound(resp, "Cannot find record for the requested identifier")
-		return
-	}
-
-	err = ctx.SkinsRepo.RemoveSkinByUserId(skin.UserId)
-	if err != nil {
-		ctx.Emit("skinsystem:error", fmt.Errorf("cannot delete skin by error: %w", err))
-		apiServerError(resp)
-		return
-	}
-
-	resp.WriteHeader(http.StatusNoContent)
-}
-
-func (ctx *Api) findIdentityOrCleanup(identityId int, username string) (*model.Skin, error) {
-	record, err := ctx.SkinsRepo.FindSkinByUserId(identityId)
-	if err != nil {
-		return nil, err
-	}
-
-	if record != nil {
-		// The username may have changed in the external database,
-		// so we need to remove the old association
-		if record.Username != username {
-			_ = ctx.SkinsRepo.RemoveSkinByUserId(identityId)
-			record.Username = username
+			return
 		}

-		return record, nil
-	}
+		cfg.Logger.IncCounter("authentication.success", 1)
+		handler.ServeHTTP(resp, req)
+	})
+}

-	// If the requested id was not found, then username was reassigned to another user
-	// who has not uploaded his data to Chrly yet
-	record, err = ctx.SkinsRepo.FindSkinByUsername(username)
+func (cfg *Config) deleteSkin(skin *model.Skin, resp http.ResponseWriter) {
+	err := cfg.SkinsRepo.RemoveByUserId(skin.UserId)
 	if err != nil {
-		return nil, err
+		cfg.Logger.Error("Cannot delete skin by error: :err", wd.ErrParam(err))
+		apiServerError(resp)
+		return
 	}

-	// If the target username does exist, clear it as it will be reassigned to the new user
-	if record != nil {
-		_ = ctx.SkinsRepo.RemoveSkinByUsername(username)
-		record.UserId = identityId
-
-		return record, nil
-	}
-
-	return nil, nil
+	cfg.Logger.IncCounter("api.skins.delete.success", 1)
+	resp.WriteHeader(http.StatusNoContent)
 }

 func validatePostSkinRequest(request *http.Request) map[string][]string {
 	const maxMultipartMemory int64 = 32 << 20
 	const oneOfSkinOrUrlMessage = "One of url or skin should be provided, but not both"

-	_ = request.ParseMultipartForm(maxMultipartMemory)
+	request.ParseMultipartForm(maxMultipartMemory)

 	validationRules := govalidator.MapData{
 		"identityId": {"required", "numeric", "min:1"},
 		"username":   {"required"},
-		"uuid":       {"required", "uuid_any"},
+		"uuid":       {"required", "uuid"},
 		"skinId":     {"required", "numeric", "min:1"},
 		"url":        {"url"},
 		"file:skin":  {"ext:png", "size:24576", "mime:image/png"},
+		"hash":       {"md5"},
 		"is1_8":      {"bool"},
 		"isSlim":     {"bool"},
 	}
@@ -196,6 +169,7 @@ func validatePostSkinRequest(request *http.Request) map[string][]string {
 	} else if skinErr == nil {
 		validationRules["file:skin"] = append(validationRules["file:skin"], "skinUploadingNotAvailable")
 	} else if url != "" {
+		validationRules["hash"] = append(validationRules["hash"], "required")
 		validationRules["is1_8"] = append(validationRules["is1_8"], "required")
 		validationRules["isSlim"] = append(validationRules["isSlim"], "required")
 	}
@@ -223,3 +197,60 @@ func validatePostSkinRequest(request *http.Request) map[string][]string {

 	return nil
 }
+
+func findIdentity(repo interfaces.SkinsRepository, identityId int, username string) (*model.Skin, error) {
+	var record *model.Skin
+	record, err := repo.FindByUserId(identityId)
+	if err != nil {
+		if _, isSkinNotFound := err.(*db.SkinNotFoundError); !isSkinNotFound {
+			return nil, err
+		}
+
+		record, err = repo.FindByUsername(username)
+		if err == nil {
+			repo.RemoveByUsername(username)
+			record.UserId = identityId
+		} else {
+			record = &model.Skin{
+				UserId:   identityId,
+				Username: username,
+			}
+		}
+	} else if record.Username != username {
+		repo.RemoveByUserId(identityId)
+		record.Username = username
+	}
+
+	return record, nil
+}
+
+func apiBadRequest(resp http.ResponseWriter, errorsPerField map[string][]string) {
+	resp.WriteHeader(http.StatusBadRequest)
+	resp.Header().Set("Content-Type", "application/json")
+	result, _ := json.Marshal(map[string]interface{}{
+		"errors": errorsPerField,
+	})
+	resp.Write(result)
+}
+
+func apiForbidden(resp http.ResponseWriter, reason string) {
+	resp.WriteHeader(http.StatusForbidden)
+	resp.Header().Set("Content-Type", "application/json")
+	result, _ := json.Marshal(map[string]interface{}{
+		"error": reason,
+	})
+	resp.Write(result)
+}
+
+func apiNotFound(resp http.ResponseWriter, reason string) {
+	resp.WriteHeader(http.StatusNotFound)
+	resp.Header().Set("Content-Type", "application/json")
+	result, _ := json.Marshal([]interface{}{
+		reason,
+	})
+	resp.Write(result)
+}
+
+func apiServerError(resp http.ResponseWriter) {
+	resp.WriteHeader(http.StatusInternalServerError)
+}
--- a/http/api_test.go
+++ b/http/api_test.go
@@ -3,8 +3,6 @@ package http
 import (
 	"bytes"
 	"encoding/base64"
-	"errors"
-	"io"
 	"io/ioutil"
 	"mime/multipart"
 	"net/http"
@@ -12,421 +10,486 @@ import (
 	"net/url"
 	"testing"

-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/suite"
+	"github.com/elyby/chrly/auth"
+	"github.com/elyby/chrly/db"

-	"github.com/elyby/chrly/model"
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
 )

-/***************
- * Setup mocks *
- ***************/
+func TestConfig_PostSkin_Valid(t *testing.T) {
+	assert := testify.New(t)

-type apiTestSuite struct {
-	suite.Suite
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()

-	App *Api
+	config, mocks := setupMocks(ctrl)

-	SkinsRepository *skinsRepositoryMock
-	Emitter         *emitterMock
-}
+	resultModel := createSkinModel("mock_user", false)
+	resultModel.SkinId = 5
+	resultModel.Hash = "94a457d92a61460cb9cb5d6f29732d2a"
+	resultModel.Url = "http://ely.by/minecraft/skins/default.png"
+	resultModel.MojangTextures = ""
+	resultModel.MojangSignature = ""

-/********************
- * Setup test suite *
- ********************/
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Skins.EXPECT().FindByUserId(1).Return(createSkinModel("mock_user", false), nil)
+	mocks.Skins.EXPECT().Save(resultModel).Return(nil)
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.success", int64(1))

-func (suite *apiTestSuite) SetupTest() {
-	suite.SkinsRepository = &skinsRepositoryMock{}
-	suite.Emitter = &emitterMock{}
-
-	suite.App = &Api{
-		SkinsRepo: suite.SkinsRepository,
-		Emitter:   suite.Emitter,
-	}
-}
-
-func (suite *apiTestSuite) TearDownTest() {
-	suite.SkinsRepository.AssertExpectations(suite.T())
-	suite.Emitter.AssertExpectations(suite.T())
-}
-
-func (suite *apiTestSuite) RunSubTest(name string, subTest func()) {
-	suite.SetupTest()
-	suite.Run(name, subTest)
-	suite.TearDownTest()
-}
-
-/*************
- * Run tests *
- *************/
-
-func TestApi(t *testing.T) {
-	suite.Run(t, new(apiTestSuite))
-}
-
-/*************************
- * Post skin tests cases *
- *************************/
-
-type postSkinTestCase struct {
-	Name       string
-	Form       io.Reader
-	BeforeTest func(suite *apiTestSuite)
-	AfterTest  func(suite *apiTestSuite, response *http.Response)
-}
-
-var postSkinTestsCases = []*postSkinTestCase{
-	{
-		Name: "Upload new identity with textures data",
-		Form: bytes.NewBufferString(url.Values{
-			"identityId": {"1"},
-			"username":   {"mock_username"},
-			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
-			"skinId":     {"5"},
-			"is1_8":      {"0"},
-			"isSlim":     {"0"},
-			"url":        {"http://example.com/skin.png"},
-		}.Encode()),
-		BeforeTest: func(suite *apiTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(nil, nil)
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.SkinsRepository.On("SaveSkin", mock.MatchedBy(func(model *model.Skin) bool {
-				suite.Equal(1, model.UserId)
-				suite.Equal("mock_username", model.Username)
-				suite.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", model.Uuid)
-				suite.Equal(5, model.SkinId)
-				suite.False(model.Is1_8)
-				suite.False(model.IsSlim)
-				suite.Equal("http://example.com/skin.png", model.Url)
-
-				return true
-			})).Times(1).Return(nil)
-		},
-		AfterTest: func(suite *apiTestSuite, response *http.Response) {
-			suite.Equal(201, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Empty(body)
-		},
-	},
-	{
-		Name: "Update exists identity by changing only textures data",
-		Form: bytes.NewBufferString(url.Values{
-			"identityId": {"1"},
-			"username":   {"mock_username"},
-			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
-			"skinId":     {"5"},
-			"is1_8":      {"1"},
-			"isSlim":     {"1"},
-			"url":        {"http://textures-server.com/skin.png"},
-		}.Encode()),
-		BeforeTest: func(suite *apiTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(createSkinModel("mock_username", false), nil)
-			suite.SkinsRepository.On("SaveSkin", mock.MatchedBy(func(model *model.Skin) bool {
-				suite.Equal(1, model.UserId)
-				suite.Equal("mock_username", model.Username)
-				suite.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", model.Uuid)
-				suite.Equal(5, model.SkinId)
-				suite.True(model.Is1_8)
-				suite.True(model.IsSlim)
-				suite.Equal("http://textures-server.com/skin.png", model.Url)
-
-				return true
-			})).Times(1).Return(nil)
-		},
-		AfterTest: func(suite *apiTestSuite, response *http.Response) {
-			suite.Equal(201, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Empty(body)
-		},
-	},
-	{
-		Name: "Update exists identity by changing its identityId",
-		Form: bytes.NewBufferString(url.Values{
-			"identityId": {"2"},
-			"username":   {"mock_username"},
-			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
-			"skinId":     {"5"},
-			"is1_8":      {"0"},
-			"isSlim":     {"0"},
-			"url":        {"http://example.com/skin.png"},
-		}.Encode()),
-		BeforeTest: func(suite *apiTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUserId", 2).Return(nil, nil)
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", false), nil)
-			suite.SkinsRepository.On("RemoveSkinByUsername", "mock_username").Times(1).Return(nil)
-			suite.SkinsRepository.On("SaveSkin", mock.MatchedBy(func(model *model.Skin) bool {
-				suite.Equal(2, model.UserId)
-				suite.Equal("mock_username", model.Username)
-				suite.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", model.Uuid)
-
-				return true
-			})).Times(1).Return(nil)
-		},
-		AfterTest: func(suite *apiTestSuite, response *http.Response) {
-			suite.Equal(201, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Empty(body)
-		},
-	},
-	{
-		Name: "Update exists identity by changing its username",
-		Form: bytes.NewBufferString(url.Values{
-			"identityId": {"1"},
-			"username":   {"changed_username"},
-			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
-			"skinId":     {"5"},
-			"is1_8":      {"0"},
-			"isSlim":     {"0"},
-			"url":        {"http://example.com/skin.png"},
-		}.Encode()),
-		BeforeTest: func(suite *apiTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(createSkinModel("mock_username", false), nil)
-			suite.SkinsRepository.On("RemoveSkinByUserId", 1).Times(1).Return(nil)
-			suite.SkinsRepository.On("SaveSkin", mock.MatchedBy(func(model *model.Skin) bool {
-				suite.Equal(1, model.UserId)
-				suite.Equal("changed_username", model.Username)
-				suite.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", model.Uuid)
-
-				return true
-			})).Times(1).Return(nil)
-		},
-		AfterTest: func(suite *apiTestSuite, response *http.Response) {
-			suite.Equal(201, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Empty(body)
-		},
-	},
-	{
-		Name: "Handle an error when loading the data from the repository",
-		Form: bytes.NewBufferString(url.Values{
-			"identityId": {"1"},
-			"username":   {"mock_username"},
-			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
-			"skinId":     {"5"},
-			"is1_8":      {"1"},
-			"isSlim":     {"1"},
-			"url":        {"http://textures-server.com/skin.png"},
-		}.Encode()),
-		BeforeTest: func(suite *apiTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(createSkinModel("mock_username", false), nil)
-			err := errors.New("mock error")
-			suite.SkinsRepository.On("SaveSkin", mock.Anything).Return(err)
-			suite.Emitter.On("Emit", "skinsystem:error", mock.MatchedBy(func(cErr error) bool {
-				return cErr.Error() == "unable to save record to the repository: mock error" &&
-					errors.Is(cErr, err)
-			})).Once()
-		},
-		AfterTest: func(suite *apiTestSuite, response *http.Response) {
-			suite.Equal(500, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Empty(body)
-		},
-	},
-	{
-		Name: "Handle an error when saving the data into the repository",
-		Form: bytes.NewBufferString(url.Values{
-			"identityId": {"1"},
-			"username":   {"changed_username"},
-			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
-			"skinId":     {"5"},
-			"is1_8":      {"0"},
-			"isSlim":     {"0"},
-			"url":        {"http://example.com/skin.png"},
-		}.Encode()),
-		BeforeTest: func(suite *apiTestSuite) {
-			err := errors.New("mock error")
-			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(nil, err)
-			suite.Emitter.On("Emit", "skinsystem:error", mock.MatchedBy(func(cErr error) bool {
-				return cErr.Error() == "error on requesting a skin from the repository: mock error" &&
-					errors.Is(cErr, err)
-			})).Once()
-		},
-		AfterTest: func(suite *apiTestSuite, response *http.Response) {
-			suite.Equal(500, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Empty(body)
-		},
-	},
-}
-
-func (suite *apiTestSuite) TestPostSkin() {
-	for _, testCase := range postSkinTestsCases {
-		suite.RunSubTest(testCase.Name, func() {
-			testCase.BeforeTest(suite)
-
-			req := httptest.NewRequest("POST", "http://chrly/skins", testCase.Form)
-			req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
-			w := httptest.NewRecorder()
-
-			suite.App.Handler().ServeHTTP(w, req)
-
-			testCase.AfterTest(suite, w.Result())
-		})
+	form := url.Values{
+		"identityId": {"1"},
+		"username":   {"mock_user"},
+		"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+		"skinId":     {"5"},
+		"hash":       {"94a457d92a61460cb9cb5d6f29732d2a"},
+		"is1_8":      {"0"},
+		"isSlim":     {"0"},
+		"url":        {"http://ely.by/minecraft/skins/default.png"},
 	}

-	suite.RunSubTest("Get errors about required fields", func() {
-		req := httptest.NewRequest("POST", "http://chrly/skins", bytes.NewBufferString(url.Values{
-			"mojangTextures": {"someBase64EncodedString"},
-		}.Encode()))
-		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
-		w := httptest.NewRecorder()
+	req := httptest.NewRequest("POST", "http://skinsystem.ely.by/api/skins", bytes.NewBufferString(form.Encode()))
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	w := httptest.NewRecorder()

-		suite.App.Handler().ServeHTTP(w, req)
+	config.CreateHandler().ServeHTTP(w, req)

-		resp := w.Result()
-		defer resp.Body.Close()
-		suite.Equal(400, resp.StatusCode)
-		body, _ := ioutil.ReadAll(resp.Body)
-		suite.JSONEq(`{
-			"errors": {
-				"identityId": [
-					"The identityId field is required",
-					"The identityId field must be numeric",
-					"The identityId field must be minimum 1 char"
-				],
-				"skinId": [
-					"The skinId field is required",
-					"The skinId field must be numeric",
-					"The skinId field must be minimum 1 char"
-				],
-				"username": [
-					"The username field is required"
-				],
-				"uuid": [
-					"The uuid field is required",
-					"The uuid field must contain valid UUID"
-				],
-				"url": [
-					"One of url or skin should be provided, but not both"
-				],
-				"skin": [
-					"One of url or skin should be provided, but not both"
-				],
-				"mojangSignature": [
-					"The mojangSignature field is required"
-				]
-			}
-		}`, string(body))
-	})
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(201, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.Empty(response)
+}

-	suite.RunSubTest("Upload textures with skin as file", func() {
-		inputBody := &bytes.Buffer{}
-		writer := multipart.NewWriter(inputBody)
+func TestConfig_PostSkin_ChangedIdentityId(t *testing.T) {
+	assert := testify.New(t)

-		part, _ := writer.CreateFormFile("skin", "char.png")
-		_, _ = part.Write(loadSkinFile())
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()

-		_ = writer.WriteField("identityId", "1")
-		_ = writer.WriteField("username", "mock_user")
-		_ = writer.WriteField("uuid", "0f657aa8-bfbe-415d-b700-5750090d3af3")
-		_ = writer.WriteField("skinId", "5")
+	config, mocks := setupMocks(ctrl)

-		err := writer.Close()
-		if err != nil {
-			panic(err)
+	resultModel := createSkinModel("mock_user", false)
+	resultModel.UserId = 2
+	resultModel.SkinId = 5
+	resultModel.Hash = "94a457d92a61460cb9cb5d6f29732d2a"
+	resultModel.Url = "http://ely.by/minecraft/skins/default.png"
+	resultModel.MojangTextures = ""
+	resultModel.MojangSignature = ""
+
+	form := url.Values{
+		"identityId": {"2"},
+		"username":   {"mock_user"},
+		"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+		"skinId":     {"5"},
+		"hash":       {"94a457d92a61460cb9cb5d6f29732d2a"},
+		"is1_8":      {"0"},
+		"isSlim":     {"0"},
+		"url":        {"http://ely.by/minecraft/skins/default.png"},
+	}
+
+	req := httptest.NewRequest("POST", "http://skinsystem.ely.by/api/skins", bytes.NewBufferString(form.Encode()))
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	w := httptest.NewRecorder()
+
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Skins.EXPECT().FindByUserId(2).Return(nil, &db.SkinNotFoundError{"unknown"})
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	mocks.Skins.EXPECT().RemoveByUsername("mock_user").Return(nil)
+	mocks.Skins.EXPECT().Save(resultModel).Return(nil)
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.success", int64(1))
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(201, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.Empty(response)
+}
+
+func TestConfig_PostSkin_ChangedUsername(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	resultModel := createSkinModel("changed_username", false)
+	resultModel.SkinId = 5
+	resultModel.Hash = "94a457d92a61460cb9cb5d6f29732d2a"
+	resultModel.Url = "http://ely.by/minecraft/skins/default.png"
+	resultModel.MojangTextures = ""
+	resultModel.MojangSignature = ""
+
+	form := url.Values{
+		"identityId": {"1"},
+		"username":   {"changed_username"},
+		"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+		"skinId":     {"5"},
+		"hash":       {"94a457d92a61460cb9cb5d6f29732d2a"},
+		"is1_8":      {"0"},
+		"isSlim":     {"0"},
+		"url":        {"http://ely.by/minecraft/skins/default.png"},
+	}
+
+	req := httptest.NewRequest("POST", "http://skinsystem.ely.by/api/skins", bytes.NewBufferString(form.Encode()))
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	w := httptest.NewRecorder()
+
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Skins.EXPECT().FindByUserId(1).Return(createSkinModel("mock_user", false), nil)
+	mocks.Skins.EXPECT().RemoveByUserId(1).Return(nil)
+	mocks.Skins.EXPECT().Save(resultModel).Return(nil)
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.success", int64(1))
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(201, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.Empty(response)
+}
+
+func TestConfig_PostSkin_CompletelyNewIdentity(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	resultModel := createSkinModel("mock_user", false)
+	resultModel.SkinId = 5
+	resultModel.Hash = "94a457d92a61460cb9cb5d6f29732d2a"
+	resultModel.Url = "http://ely.by/minecraft/skins/default.png"
+	resultModel.MojangTextures = ""
+	resultModel.MojangSignature = ""
+
+	form := url.Values{
+		"identityId": {"1"},
+		"username":   {"mock_user"},
+		"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+		"skinId":     {"5"},
+		"hash":       {"94a457d92a61460cb9cb5d6f29732d2a"},
+		"is1_8":      {"0"},
+		"isSlim":     {"0"},
+		"url":        {"http://ely.by/minecraft/skins/default.png"},
+	}
+
+	req := httptest.NewRequest("POST", "http://skinsystem.ely.by/api/skins", bytes.NewBufferString(form.Encode()))
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	w := httptest.NewRecorder()
+
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Skins.EXPECT().FindByUserId(1).Return(nil, &db.SkinNotFoundError{"unknown"})
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(nil, &db.SkinNotFoundError{"mock_user"})
+	mocks.Skins.EXPECT().Save(resultModel).Return(nil)
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.success", int64(1))
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(201, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.Empty(response)
+}
+
+func TestConfig_PostSkin_UploadSkin(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+
+	part, _ := writer.CreateFormFile("skin", "char.png")
+	part.Write(loadSkinFile())
+
+	_ = writer.WriteField("identityId", "1")
+	_ = writer.WriteField("username", "mock_user")
+	_ = writer.WriteField("uuid", "0f657aa8-bfbe-415d-b700-5750090d3af3")
+	_ = writer.WriteField("skinId", "5")
+
+	err := writer.Close()
+	if err != nil {
+		panic(err)
+	}
+
+	req := httptest.NewRequest("POST", "http://skinsystem.ely.by/api/skins", body)
+	req.Header.Add("Content-Type", writer.FormDataContentType())
+	w := httptest.NewRecorder()
+
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.validation_failed", int64(1))
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(400, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"errors": {
+			"skin": [
+			    "Skin uploading is temporary unavailable"
+			]
 		}
-
-		req := httptest.NewRequest("POST", "http://chrly/skins", inputBody)
-		req.Header.Add("Content-Type", writer.FormDataContentType())
-		w := httptest.NewRecorder()
-
-		suite.App.Handler().ServeHTTP(w, req)
-
-		resp := w.Result()
-		defer resp.Body.Close()
-		suite.Equal(400, resp.StatusCode)
-		responseBody, _ := ioutil.ReadAll(resp.Body)
-		suite.JSONEq(`{
-			"errors": {
-				"skin": [
-					"Skin uploading is temporary unavailable"
-				]
-			}
-		}`, string(responseBody))
-	})
+	}`, string(response))
 }

-/**************************************
- * Delete skin by user id tests cases *
- **************************************/
+func TestConfig_PostSkin_RequiredFields(t *testing.T) {
+	assert := testify.New(t)

-func (suite *apiTestSuite) TestDeleteByUserId() {
-	suite.RunSubTest("Delete skin by its identity id", func() {
-		suite.SkinsRepository.On("FindSkinByUserId", 1).Return(createSkinModel("mock_username", false), nil)
-		suite.SkinsRepository.On("RemoveSkinByUserId", 1).Once().Return(nil)
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()

-		req := httptest.NewRequest("DELETE", "http://chrly/skins/id:1", nil)
-		w := httptest.NewRecorder()
+	config, mocks := setupMocks(ctrl)

-		suite.App.Handler().ServeHTTP(w, req)
+	form := url.Values{
+		"hash":           {"this is not md5"},
+		"mojangTextures": {"someBase64EncodedString"},
+	}

-		resp := w.Result()
-		defer resp.Body.Close()
-		suite.Equal(204, resp.StatusCode)
-		body, _ := ioutil.ReadAll(resp.Body)
-		suite.Empty(body)
-	})
+	req := httptest.NewRequest("POST", "http://skinsystem.ely.by/api/skins", bytes.NewBufferString(form.Encode()))
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	w := httptest.NewRecorder()

-	suite.RunSubTest("Try to remove not exists identity id", func() {
-		suite.SkinsRepository.On("FindSkinByUserId", 1).Return(nil, nil)
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.post.validation_failed", int64(1))

-		req := httptest.NewRequest("DELETE", "http://chrly/skins/id:1", nil)
-		w := httptest.NewRecorder()
+	config.CreateHandler().ServeHTTP(w, req)

-		suite.App.Handler().ServeHTTP(w, req)
-
-		resp := w.Result()
-		defer resp.Body.Close()
-		suite.Equal(404, resp.StatusCode)
-		body, _ := ioutil.ReadAll(resp.Body)
-		suite.JSONEq(`[
-			"Cannot find record for the requested identifier"
-		]`, string(body))
-	})
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(400, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"errors": {
+			"identityId": [
+			    "The identityId field is required",
+				"The identityId field must be numeric",
+				"The identityId field must be minimum 1 char"
+			],
+            "skinId": [
+				"The skinId field is required",
+				"The skinId field must be numeric",
+				"The skinId field must be minimum 1 char"
+			],
+			"username": [
+				"The username field is required"
+			],
+			"uuid": [
+				"The uuid field is required",
+				"The uuid field must contain valid UUID"
+			],
+			"hash": [
+				"The hash field must be a valid md5 hash"
+			],
+			"url": [
+				"One of url or skin should be provided, but not both"
+			],
+			"skin": [
+				"One of url or skin should be provided, but not both"
+			],
+			"mojangSignature": [
+				"The mojangSignature field is required"
+			]
+		}
+	}`, string(response))
 }

-/***************************************
- * Delete skin by username tests cases *
- ***************************************/
+func TestConfig_PostSkin_Unauthorized(t *testing.T) {
+	assert := testify.New(t)

-func (suite *apiTestSuite) TestDeleteByUsername() {
-	suite.RunSubTest("Delete skin by its identity username", func() {
-		suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", false), nil)
-		suite.SkinsRepository.On("RemoveSkinByUserId", 1).Once().Return(nil)
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()

-		req := httptest.NewRequest("DELETE", "http://chrly/skins/mock_username", nil)
-		w := httptest.NewRecorder()
+	config, mocks := setupMocks(ctrl)

-		suite.App.Handler().ServeHTTP(w, req)
+	req := httptest.NewRequest("POST", "http://skinsystem.ely.by/api/skins", nil)
+	req.Header.Add("Authorization", "Bearer invalid.jwt.token")
+	w := httptest.NewRecorder()

-		resp := w.Result()
-		defer resp.Body.Close()
-		suite.Equal(204, resp.StatusCode)
-		body, _ := ioutil.ReadAll(resp.Body)
-		suite.Empty(body)
-	})
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(&auth.Unauthorized{"Cannot parse passed JWT token"})
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.failed", int64(1))

-	suite.RunSubTest("Try to remove not exists identity username", func() {
-		suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
+	config.CreateHandler().ServeHTTP(w, req)

-		req := httptest.NewRequest("DELETE", "http://chrly/skins/mock_username", nil)
-		w := httptest.NewRecorder()
-
-		suite.App.Handler().ServeHTTP(w, req)
-
-		resp := w.Result()
-		defer resp.Body.Close()
-		suite.Equal(404, resp.StatusCode)
-		body, _ := ioutil.ReadAll(resp.Body)
-		suite.JSONEq(`[
-			"Cannot find record for the requested identifier"
-		]`, string(body))
-	})
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(403, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"error": "Cannot parse passed JWT token"
+	}`, string(response))
 }

-/*************
- * Utilities *
- *************/
+func TestConfig_DeleteSkinByUserId_Success(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	req := httptest.NewRequest("DELETE", "http://skinsystem.ely.by/api/skins/id:1", nil)
+	w := httptest.NewRecorder()
+
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Skins.EXPECT().FindByUserId(1).Return(createSkinModel("mock_user", false), nil)
+	mocks.Skins.EXPECT().RemoveByUserId(1).Return(nil)
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.delete.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.delete.success", int64(1))
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(204, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.Empty(response)
+}
+
+func TestConfig_DeleteSkinByUserId_NotFound(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	req := httptest.NewRequest("DELETE", "http://skinsystem.ely.by/api/skins/id:2", nil)
+	w := httptest.NewRecorder()
+
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Skins.EXPECT().FindByUserId(2).Return(nil, &db.SkinNotFoundError{"unknown"})
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.delete.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.delete.not_found", int64(1))
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(404, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`[
+		"Cannot find record for requested user id"
+	]`, string(response))
+}
+
+func TestConfig_DeleteSkinByUsername_Success(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	req := httptest.NewRequest("DELETE", "http://skinsystem.ely.by/api/skins/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	mocks.Skins.EXPECT().RemoveByUserId(1).Return(nil)
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.delete.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.delete.success", int64(1))
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(204, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.Empty(response)
+}
+
+func TestConfig_DeleteSkinByUsername_NotFound(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	req := httptest.NewRequest("DELETE", "http://skinsystem.ely.by/api/skins/mock_user_2", nil)
+	w := httptest.NewRecorder()
+
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+	mocks.Skins.EXPECT().FindByUsername("mock_user_2").Return(nil, &db.SkinNotFoundError{"mock_user_2"})
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.delete.request", int64(1))
+	mocks.Log.EXPECT().IncCounter("api.skins.delete.not_found", int64(1))
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(404, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`[
+		"Cannot find record for requested username"
+	]`, string(response))
+}
+
+func TestConfig_Authenticate_SignatureKeyNotSet(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	w := httptest.NewRecorder()
+
+	mocks.Auth.EXPECT().Check(gomock.Any()).Return(&auth.Unauthorized{"signing key not available"})
+	mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+	mocks.Log.EXPECT().IncCounter("authentication.failed", int64(1))
+
+	res := config.Authenticate(http.HandlerFunc(func (resp http.ResponseWriter, req *http.Request) {}))
+	res.ServeHTTP(w, req)
+
+	resp := w.Result()
+	defer resp.Body.Close()
+	assert.Equal(403, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"error": "signing key not available"
+	}`, string(response))
+}

 // base64 https://github.com/mathiasbynens/small/blob/0ca3c51/png-transparent.png
 var OnePxPng = []byte("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg==")
--- a/http/cape.go
+++ b/http/cape.go
@@ -0,0 +1,38 @@
+package http
+
+import (
+	"io"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+func (cfg *Config) Cape(response http.ResponseWriter, request *http.Request) {
+	if mux.Vars(request)["converted"] == "" {
+		cfg.Logger.IncCounter("capes.request", 1)
+	}
+
+	username := parseUsername(mux.Vars(request)["username"])
+	rec, err := cfg.CapesRepo.FindByUsername(username)
+	if err != nil {
+		http.Redirect(response, request, "http://skins.minecraft.net/MinecraftCloaks/" + username + ".png", 301)
+		return
+	}
+
+	request.Header.Set("Content-Type", "image/png")
+	io.Copy(response, rec.File)
+}
+
+func (cfg *Config) CapeGET(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("capes.get_request", 1)
+	username := request.URL.Query().Get("name")
+	if username == "" {
+		response.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	mux.Vars(request)["username"] = username
+	mux.Vars(request)["converted"] = "1"
+
+	cfg.Cape(response, request)
+}
--- a/http/cape_test.go
+++ b/http/cape_test.go
@@ -0,0 +1,138 @@
+package http
+
+import (
+	"bytes"
+	"image"
+	"image/png"
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/model"
+)
+
+func TestConfig_Cape(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	cape := createCape()
+
+	mocks.Capes.EXPECT().FindByUsername("mocked_username").Return(&model.Cape{
+		File: bytes.NewReader(cape),
+	}, nil)
+	mocks.Log.EXPECT().IncCounter("capes.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks/mocked_username", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	responseData, _ := ioutil.ReadAll(resp.Body)
+	assert.Equal(cape, responseData)
+	assert.Equal("image/png", resp.Header.Get("Content-Type"))
+}
+
+func TestConfig_Cape2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Capes.EXPECT().FindByUsername("notch").Return(nil, &db.CapeNotFoundError{"notch"})
+	mocks.Log.EXPECT().IncCounter("capes.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks/notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skins.minecraft.net/MinecraftCloaks/notch.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_CapeGET(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	cape := createCape()
+
+	mocks.Capes.EXPECT().FindByUsername("mocked_username").Return(&model.Cape{
+		File: bytes.NewReader(cape),
+	}, nil)
+	mocks.Log.EXPECT().IncCounter("capes.request", int64(1)).Times(0)
+	mocks.Log.EXPECT().IncCounter("capes.get_request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks?name=mocked_username", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	responseData, _ := ioutil.ReadAll(resp.Body)
+	assert.Equal(cape, responseData)
+	assert.Equal("image/png", resp.Header.Get("Content-Type"))
+}
+
+func TestConfig_CapeGET2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Capes.EXPECT().FindByUsername("notch").Return(nil, &db.CapeNotFoundError{"notch"})
+	mocks.Log.EXPECT().IncCounter("capes.request", int64(1)).Times(0)
+	mocks.Log.EXPECT().IncCounter("capes.get_request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks?name=notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skins.minecraft.net/MinecraftCloaks/notch.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_CapeGET3(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks/?name=notch", nil)
+	w := httptest.NewRecorder()
+
+	(&Config{}).CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skinsystem.ely.by/cloaks?name=notch", resp.Header.Get("Location"))
+}
+
+// Cape md5: 424ff79dce9940af89c28ad80de8aaad
+func createCape() []byte {
+	img := image.NewAlpha(image.Rect(0, 0, 64, 32))
+	writer := &bytes.Buffer{}
+	png.Encode(writer, img)
+
+	pngBytes, _ := ioutil.ReadAll(writer)
+
+	return pngBytes
+}
--- a/http/face.go
+++ b/http/face.go
@@ -0,0 +1,27 @@
+package http
+
+import (
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+const defaultHash = "default"
+
+func (cfg *Config) Face(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("faces.request", 1)
+	username := parseUsername(mux.Vars(request)["username"])
+	rec, err := cfg.SkinsRepo.FindByUsername(username)
+	var hash string
+	if err != nil || rec.SkinId == 0 {
+		hash = defaultHash
+	} else {
+		hash = rec.Hash
+	}
+
+	http.Redirect(response, request, buildFaceUrl(hash), 301)
+}
+
+func buildFaceUrl(hash string) string {
+	return "http://ely.by/minecraft/skin_buffer/faces/" + hash + ".png"
+}
--- a/http/face_test.go
+++ b/http/face_test.go
@@ -0,0 +1,53 @@
+package http
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/db"
+)
+
+func TestConfig_Face(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	mocks.Log.EXPECT().IncCounter("faces.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/mock_user/face.png", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://ely.by/minecraft/skin_buffer/faces/55d2a8848764f5ff04012cdb093458bd.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_Face2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(nil, &db.SkinNotFoundError{"mock_user"})
+	mocks.Log.EXPECT().IncCounter("faces.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/mock_user/face.png", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://ely.by/minecraft/skin_buffer/faces/default.png", resp.Header.Get("Location"))
+}
--- a/http/http.go
+++ b/http/http.go
@@ -1,138 +1,87 @@
 package http

 import (
-	"context"
-	"encoding/json"
+	"fmt"
+	"net"
 	"net/http"
 	"os"
 	"os/signal"
 	"strings"
+	"syscall"
+	"time"

 	"github.com/gorilla/mux"
-	"github.com/mono83/slf"
 	"github.com/mono83/slf/wd"

-	"github.com/elyby/chrly/dispatcher"
+	"github.com/elyby/chrly/interfaces"
 )

-type Emitter interface {
-	dispatcher.Emitter
+type Config struct {
+	ListenSpec string
+
+	SkinsRepo interfaces.SkinsRepository
+	CapesRepo interfaces.CapesRepository
+	Logger    wd.Watchdog
+	Auth      interfaces.AuthChecker
 }

-func StartServer(server *http.Server, logger slf.Logger) {
-	done := make(chan bool, 1)
-	go func() {
-		logger.Info("Starting the server, HTTP on: :addr", wd.StringParam("addr", server.Addr))
-		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.Emergency("Error in main(): :err", wd.ErrParam(err))
-		}
+func (cfg *Config) Run() error {
+	cfg.Logger.Info(fmt.Sprintf("Starting, HTTP on: %s\n", cfg.ListenSpec))

-		close(done)
-	}()
+	listener, err := net.Listen("tcp", cfg.ListenSpec)
+	if err != nil {
+		return err
+	}

-	go func() {
-		s := waitForExitSignal()
-		logger.Info("Got signal: :signal, starting graceful shutdown", wd.StringParam("signal", s.String()))
-		server.Shutdown(context.Background())
-		logger.Info("Graceful shutdown succeed, exiting", wd.StringParam("signal", s.String()))
-		close(done)
-	}()
+	server := &http.Server{
+		ReadTimeout:    60 * time.Second,
+		WriteTimeout:   60 * time.Second,
+		MaxHeaderBytes: 1 << 16,
+		Handler:        cfg.CreateHandler(),
+	}

-	<-done
+	go server.Serve(listener)
+
+	s := waitForSignal()
+	cfg.Logger.Info(fmt.Sprintf("Got signal: %v, exiting.", s))
+
+	return nil
 }

-func waitForExitSignal() os.Signal {
-	ch := make(chan os.Signal, 1)
-	signal.Notify(ch, os.Interrupt, os.Kill)
+func (cfg *Config) CreateHandler() http.Handler {
+	router := mux.NewRouter().StrictSlash(true)
+
+	router.HandleFunc("/skins/{username}", cfg.Skin).Methods("GET")
+	router.HandleFunc("/cloaks/{username}", cfg.Cape).Methods("GET").Name("cloaks")
+	router.HandleFunc("/textures/{username}", cfg.Textures).Methods("GET")
+	router.HandleFunc("/textures/signed/{username}", cfg.SignedTextures).Methods("GET")
+	router.HandleFunc("/skins/{username}/face", cfg.Face).Methods("GET")
+	router.HandleFunc("/skins/{username}/face.png", cfg.Face).Methods("GET")
+	// Legacy
+	router.HandleFunc("/skins", cfg.SkinGET).Methods("GET")
+	router.HandleFunc("/cloaks", cfg.CapeGET).Methods("GET")
+	// API
+	router.Handle("/api/skins", cfg.Authenticate(http.HandlerFunc(cfg.PostSkin))).Methods("POST")
+	router.Handle("/api/skins/id:{id:[0-9]+}", cfg.Authenticate(http.HandlerFunc(cfg.DeleteSkinByUserId))).Methods("DELETE")
+	router.Handle("/api/skins/{username}", cfg.Authenticate(http.HandlerFunc(cfg.DeleteSkinByUsername))).Methods("DELETE")
+	// 404
+	router.NotFoundHandler = http.HandlerFunc(cfg.NotFound)
+
+	return router
+}
+
+func parseUsername(username string) string {
+	const suffix = ".png"
+	if strings.HasSuffix(username, suffix) {
+		username = strings.TrimSuffix(username, suffix)
+	}
+
+	return username
+}
+
+func waitForSignal() os.Signal {
+	ch := make(chan os.Signal)
+	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)

 	return <-ch
 }
-
-type loggingResponseWriter struct {
-	http.ResponseWriter
-	statusCode int
-}
-
-func (lrw *loggingResponseWriter) WriteHeader(code int) {
-	lrw.statusCode = code
-	lrw.ResponseWriter.WriteHeader(code)
-}
-
-func CreateRequestEventsMiddleware(emitter Emitter, prefix string) mux.MiddlewareFunc {
-	beforeTopic := strings.Join([]string{prefix, "before_request"}, ":")
-	afterTopic := strings.Join([]string{prefix, "after_request"}, ":")
-
-	return func(handler http.Handler) http.Handler {
-		return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
-			emitter.Emit(beforeTopic, req)
-
-			lrw := &loggingResponseWriter{
-				ResponseWriter: resp,
-				statusCode:     http.StatusOK,
-			}
-			handler.ServeHTTP(lrw, req)
-
-			emitter.Emit(afterTopic, req, lrw.statusCode)
-		})
-	}
-}
-
-type Authenticator interface {
-	Authenticate(req *http.Request) error
-}
-
-func CreateAuthenticationMiddleware(checker Authenticator) mux.MiddlewareFunc {
-	return func(handler http.Handler) http.Handler {
-		return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
-			err := checker.Authenticate(req)
-			if err != nil {
-				apiForbidden(resp, err.Error())
-				return
-			}
-
-			handler.ServeHTTP(resp, req)
-		})
-	}
-}
-
-func NotFoundHandler(response http.ResponseWriter, _ *http.Request) {
-	data, _ := json.Marshal(map[string]string{
-		"status":  "404",
-		"message": "Not Found",
-	})
-
-	response.Header().Set("Content-Type", "application/json")
-	response.WriteHeader(http.StatusNotFound)
-	_, _ = response.Write(data)
-}
-
-func apiBadRequest(resp http.ResponseWriter, errorsPerField map[string][]string) {
-	resp.WriteHeader(http.StatusBadRequest)
-	resp.Header().Set("Content-Type", "application/json")
-	result, _ := json.Marshal(map[string]interface{}{
-		"errors": errorsPerField,
-	})
-	_, _ = resp.Write(result)
-}
-
-func apiForbidden(resp http.ResponseWriter, reason string) {
-	resp.WriteHeader(http.StatusForbidden)
-	resp.Header().Set("Content-Type", "application/json")
-	result, _ := json.Marshal(map[string]interface{}{
-		"error": reason,
-	})
-	_, _ = resp.Write(result)
-}
-
-func apiNotFound(resp http.ResponseWriter, reason string) {
-	resp.WriteHeader(http.StatusNotFound)
-	resp.Header().Set("Content-Type", "application/json")
-	result, _ := json.Marshal([]interface{}{
-		reason,
-	})
-	_, _ = resp.Write(result)
-}
-
-func apiServerError(resp http.ResponseWriter) {
-	resp.WriteHeader(http.StatusInternalServerError)
-}
--- a/http/http_test.go
+++ b/http/http_test.go
@@ -1,112 +1,46 @@
 package http

 import (
-	"errors"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
 	"testing"

+	"github.com/golang/mock/gomock"
 	testify "github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
+
+	"github.com/elyby/chrly/interfaces/mock_interfaces"
+	"github.com/elyby/chrly/interfaces/mock_wd"
 )

-type emitterMock struct {
-	mock.Mock
-}
-
-func (e *emitterMock) Emit(name string, args ...interface{}) {
-	e.Called(append([]interface{}{name}, args...)...)
-}
-
-func TestCreateRequestEventsMiddleware(t *testing.T) {
-	req := httptest.NewRequest("GET", "http://example.com", nil)
-	resp := httptest.NewRecorder()
-
-	emitter := &emitterMock{}
-	emitter.On("Emit", "test_prefix:before_request", req)
-	emitter.On("Emit", "test_prefix:after_request", req, 400)
-
-	isHandlerCalled := false
-	middlewareFunc := CreateRequestEventsMiddleware(emitter, "test_prefix")
-	middlewareFunc.Middleware(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
-		resp.WriteHeader(400)
-		isHandlerCalled = true
-	})).ServeHTTP(resp, req)
-
-	if !isHandlerCalled {
-		t.Fatal("Handler isn't called from the middleware")
-	}
-
-	emitter.AssertExpectations(t)
-}
-
-type authCheckerMock struct {
-	mock.Mock
-}
-
-func (m *authCheckerMock) Authenticate(req *http.Request) error {
-	args := m.Called(req)
-	return args.Error(0)
-}
-
-func TestCreateAuthenticationMiddleware(t *testing.T) {
-	t.Run("pass", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "http://example.com", nil)
-		resp := httptest.NewRecorder()
-
-		auth := &authCheckerMock{}
-		auth.On("Authenticate", req).Once().Return(nil)
-
-		isHandlerCalled := false
-		middlewareFunc := CreateAuthenticationMiddleware(auth)
-		middlewareFunc.Middleware(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
-			isHandlerCalled = true
-		})).ServeHTTP(resp, req)
-
-		testify.True(t, isHandlerCalled, "Handler isn't called from the middleware")
-
-		auth.AssertExpectations(t)
-	})
-
-	t.Run("fail", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "http://example.com", nil)
-		resp := httptest.NewRecorder()
-
-		auth := &authCheckerMock{}
-		auth.On("Authenticate", req).Once().Return(errors.New("error reason"))
-
-		isHandlerCalled := false
-		middlewareFunc := CreateAuthenticationMiddleware(auth)
-		middlewareFunc.Middleware(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
-			isHandlerCalled = true
-		})).ServeHTTP(resp, req)
-
-		testify.False(t, isHandlerCalled, "Handler shouldn't be called")
-		testify.Equal(t, 403, resp.Code)
-		body, _ := ioutil.ReadAll(resp.Body)
-		testify.JSONEq(t, `{
-			"error": "error reason"
-		}`, string(body))
-
-		auth.AssertExpectations(t)
-	})
-}
-
-func TestNotFoundHandler(t *testing.T) {
+func TestParseUsername(t *testing.T) {
 	assert := testify.New(t)
-
-	req := httptest.NewRequest("GET", "http://example.com", nil)
-	w := httptest.NewRecorder()
-
-	NotFoundHandler(w, req)
-
-	resp := w.Result()
-	assert.Equal(404, resp.StatusCode)
-	assert.Equal("application/json", resp.Header.Get("Content-Type"))
-	response, _ := ioutil.ReadAll(resp.Body)
-	assert.JSONEq(`{
-		"status": "404",
-		"message": "Not Found"
-	}`, string(response))
+	assert.Equal("test", parseUsername("test.png"), "Function should trim .png at end")
+	assert.Equal("test", parseUsername("test"), "Function should return string itself, if it not contains .png at end")
+}
+
+type mocks struct {
+	Skins *mock_interfaces.MockSkinsRepository
+	Capes *mock_interfaces.MockCapesRepository
+	Auth  *mock_interfaces.MockAuthChecker
+	Log   *mock_wd.MockWatchdog
+}
+
+func setupMocks(ctrl *gomock.Controller) (
+	*Config,
+	*mocks,
+) {
+	skinsRepo := mock_interfaces.NewMockSkinsRepository(ctrl)
+	capesRepo := mock_interfaces.NewMockCapesRepository(ctrl)
+	authChecker := mock_interfaces.NewMockAuthChecker(ctrl)
+	wd := mock_wd.NewMockWatchdog(ctrl)
+
+	return &Config{
+		SkinsRepo: skinsRepo,
+		CapesRepo: capesRepo,
+		Auth:      authChecker,
+		Logger:    wd,
+	}, &mocks{
+		Skins: skinsRepo,
+		Capes: capesRepo,
+		Auth:  authChecker,
+		Log:   wd,
+	}
 }
--- a/http/jwt_test.go
+++ b/http/jwt_test.go
@@ -1,127 +0,0 @@
-package http
-
-import (
-	"net/http/httptest"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-)
-
-const jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxNTE2NjU4MTkzIiwic2NvcGVzIjoic2tpbiJ9.agbBS0qdyYMBaVfTZJAZcTTRgW1Y0kZty4H3N2JHBO8"
-
-func TestJwtAuth_NewToken(t *testing.T) {
-	t.Run("success", func(t *testing.T) {
-		jwt := &JwtAuth{Key: []byte("secret")}
-		token, err := jwt.NewToken(SkinScope)
-		assert.Nil(t, err)
-		assert.NotNil(t, token)
-	})
-
-	t.Run("key not provided", func(t *testing.T) {
-		jwt := &JwtAuth{}
-		token, err := jwt.NewToken(SkinScope)
-		assert.Error(t, err, "signing key not available")
-		assert.Nil(t, token)
-	})
-}
-
-func TestJwtAuth_Authenticate(t *testing.T) {
-	t.Run("success", func(t *testing.T) {
-		emitter := &emitterMock{}
-		emitter.On("Emit", "authentication:success")
-
-		req := httptest.NewRequest("POST", "http://localhost", nil)
-		req.Header.Add("Authorization", "Bearer " + jwt)
-		jwt := &JwtAuth{Key: []byte("secret"), Emitter: emitter}
-
-		err := jwt.Authenticate(req)
-		assert.Nil(t, err)
-
-		emitter.AssertExpectations(t)
-	})
-
-	t.Run("request without auth header", func(t *testing.T) {
-		emitter := &emitterMock{}
-		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
-			assert.Error(t, err, "Authentication header not presented")
-			return true
-		}))
-
-		req := httptest.NewRequest("POST", "http://localhost", nil)
-		jwt := &JwtAuth{Key: []byte("secret"), Emitter: emitter}
-
-		err := jwt.Authenticate(req)
-		assert.Error(t, err, "Authentication header not presented")
-
-		emitter.AssertExpectations(t)
-	})
-
-	t.Run("no bearer token prefix", func(t *testing.T) {
-		emitter := &emitterMock{}
-		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
-			assert.Error(t, err, "Cannot recognize JWT token in passed value")
-			return true
-		}))
-
-		req := httptest.NewRequest("POST", "http://localhost", nil)
-		req.Header.Add("Authorization", "this is not jwt")
-		jwt := &JwtAuth{Key: []byte("secret"), Emitter: emitter}
-
-		err := jwt.Authenticate(req)
-		assert.Error(t, err, "Cannot recognize JWT token in passed value")
-
-		emitter.AssertExpectations(t)
-	})
-
-	t.Run("bearer token but not jwt", func(t *testing.T) {
-		emitter := &emitterMock{}
-		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
-			assert.Error(t, err, "Cannot parse passed JWT token")
-			return true
-		}))
-
-		req := httptest.NewRequest("POST", "http://localhost", nil)
-		req.Header.Add("Authorization", "Bearer thisIs.Not.Jwt")
-		jwt := &JwtAuth{Key: []byte("secret"), Emitter: emitter}
-
-		err := jwt.Authenticate(req)
-		assert.Error(t, err, "Cannot parse passed JWT token")
-
-		emitter.AssertExpectations(t)
-	})
-
-	t.Run("when secret is not set", func(t *testing.T) {
-		emitter := &emitterMock{}
-		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
-			assert.Error(t, err, "Signing key not set")
-			return true
-		}))
-
-		req := httptest.NewRequest("POST", "http://localhost", nil)
-		req.Header.Add("Authorization", "Bearer " + jwt)
-		jwt := &JwtAuth{Emitter: emitter}
-
-		err := jwt.Authenticate(req)
-		assert.Error(t, err, "Signing key not set")
-
-		emitter.AssertExpectations(t)
-	})
-
-	t.Run("invalid signature", func(t *testing.T) {
-		emitter := &emitterMock{}
-		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
-			assert.Error(t, err, "JWT token have invalid signature. It may be corrupted or expired")
-			return true
-		}))
-
-		req := httptest.NewRequest("POST", "http://localhost", nil)
-		req.Header.Add("Authorization", "Bearer " + jwt)
-		jwt := &JwtAuth{Key: []byte("this is another secret"), Emitter: emitter}
-
-		err := jwt.Authenticate(req)
-		assert.Error(t, err, "JWT token have invalid signature. It may be corrupted or expired")
-
-		emitter.AssertExpectations(t)
-	})
-}
--- a/http/not_found.go
+++ b/http/not_found.go
@@ -0,0 +1,18 @@
+package http
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+func (cfg *Config) NotFound(response http.ResponseWriter, request *http.Request) {
+	data, _ := json.Marshal(map[string]string{
+		"status":  "404",
+		"message": "Not Found",
+		"link": "http://docs.ely.by/skin-system.html",
+	})
+
+	response.Header().Set("Content-Type", "application/json")
+	response.WriteHeader(http.StatusNotFound)
+	response.Write(data)
+}
--- a/http/not_found_test.go
+++ b/http/not_found_test.go
@@ -0,0 +1,28 @@
+package http
+
+import (
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+
+	testify "github.com/stretchr/testify/assert"
+)
+
+func TestConfig_NotFound(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/", nil)
+	w := httptest.NewRecorder()
+
+	(&Config{}).CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(404, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"status": "404",
+		"message": "Not Found",
+		"link": "http://docs.ely.by/skin-system.html"
+	}`, string(response))
+}
--- a/http/signed_textures.go
+++ b/http/signed_textures.go
@@ -0,0 +1,52 @@
+package http
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
+)
+
+type signedTexturesResponse struct {
+	Id    string     `json:"id"`
+	Name  string     `json:"name"`
+	Props []property `json:"properties"`
+}
+
+type property struct {
+	Name      string `json:"name"`
+	Signature string `json:"signature,omitempty"`
+	Value     string `json:"value"`
+}
+
+func (cfg *Config) SignedTextures(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("signed_textures.request", 1)
+	username := parseUsername(mux.Vars(request)["username"])
+
+	rec, err := cfg.SkinsRepo.FindByUsername(username)
+	if err != nil || rec.SkinId == 0 || rec.MojangTextures == "" {
+		response.WriteHeader(http.StatusNoContent)
+		return
+	}
+
+	responseData:= signedTexturesResponse{
+		Id: strings.Replace(rec.Uuid, "-", "", -1),
+		Name: rec.Username,
+		Props: []property{
+			{
+				Name: "textures",
+				Signature: rec.MojangSignature,
+				Value: rec.MojangTextures,
+			},
+			{
+				Name: "ely",
+				Value: "but why are you asking?",
+			},
+		},
+	}
+
+	responseJson,_ := json.Marshal(responseData)
+	response.Header().Set("Content-Type", "application/json")
+	response.Write(responseJson)
+}
--- a/http/signed_textures_test.go
+++ b/http/signed_textures_test.go
@@ -0,0 +1,71 @@
+package http
+
+import (
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/db"
+)
+
+func TestConfig_SignedTextures(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	mocks.Log.EXPECT().IncCounter("signed_textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/signed/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"id": "0f657aa8bfbe415db7005750090d3af3",
+		"name": "mock_user",
+		"properties": [
+			{
+				"name": "textures",
+				"signature": "mocked signature",
+				"value": "mocked textures base64"
+			},
+			{
+				"name": "ely",
+				"value": "but why are you asking?"
+			}
+		]
+	}`, string(response))
+}
+
+func TestConfig_SignedTextures2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(nil, &db.SkinNotFoundError{})
+	mocks.Log.EXPECT().IncCounter("signed_textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/signed/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(204, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.Equal("", string(response))
+}
--- a/http/skin.go
+++ b/http/skin.go
@@ -0,0 +1,36 @@
+package http
+
+import (
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+func (cfg *Config) Skin(response http.ResponseWriter, request *http.Request) {
+	if mux.Vars(request)["converted"] == "" {
+		cfg.Logger.IncCounter("skins.request", 1)
+	}
+
+	username := parseUsername(mux.Vars(request)["username"])
+	rec, err := cfg.SkinsRepo.FindByUsername(username)
+	if err != nil || rec.SkinId == 0 {
+		http.Redirect(response, request, "http://skins.minecraft.net/MinecraftSkins/" + username + ".png", 301)
+		return
+	}
+
+	http.Redirect(response, request, rec.Url, 301)
+}
+
+func (cfg *Config) SkinGET(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("skins.get_request", 1)
+	username := request.URL.Query().Get("name")
+	if username == "" {
+		response.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	mux.Vars(request)["username"] = username
+	mux.Vars(request)["converted"] = "1"
+
+	cfg.Skin(response, request)
+}
--- a/http/skin_test.go
+++ b/http/skin_test.go
@@ -0,0 +1,125 @@
+package http
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/model"
+)
+
+func TestConfig_Skin(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	mocks.Log.EXPECT().IncCounter("skins.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://ely.by/minecraft/skins/skin.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_Skin2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("notch").Return(nil, &db.SkinNotFoundError{"notch"})
+	mocks.Log.EXPECT().IncCounter("skins.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skins.minecraft.net/MinecraftSkins/notch.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_SkinGET(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	mocks.Log.EXPECT().IncCounter("skins.get_request", int64(1))
+	mocks.Log.EXPECT().IncCounter("skins.request", int64(1)).Times(0)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins?name=mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://ely.by/minecraft/skins/skin.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_SkinGET2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("notch").Return(nil, &db.SkinNotFoundError{"notch"})
+	mocks.Log.EXPECT().IncCounter("skins.get_request", int64(1))
+	mocks.Log.EXPECT().IncCounter("skins.request", int64(1)).Times(0)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins?name=notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skins.minecraft.net/MinecraftSkins/notch.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_SkinGET3(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/?name=notch", nil)
+	w := httptest.NewRecorder()
+
+	(&Config{}).CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skinsystem.ely.by/skins?name=notch", resp.Header.Get("Location"))
+}
+
+func createSkinModel(username string, isSlim bool) *model.Skin {
+	return &model.Skin{
+		UserId:          1,
+		Username:        username,
+		Uuid:            "0f657aa8-bfbe-415d-b700-5750090d3af3",
+		SkinId:          1,
+		Hash:            "55d2a8848764f5ff04012cdb093458bd",
+		Url:             "http://ely.by/minecraft/skins/skin.png",
+		MojangTextures:  "mocked textures base64",
+		MojangSignature: "mocked signature",
+		IsSlim:          isSlim,
+	}
+}
--- a/http/skinsystem.go
+++ b/http/skinsystem.go
@@ -1,226 +0,0 @@
-package http
-
-import (
-	"encoding/json"
-	"errors"
-	"io"
-	"net/http"
-	"strings"
-
-	"github.com/gorilla/mux"
-
-	"github.com/elyby/chrly/api/mojang"
-	"github.com/elyby/chrly/model"
-)
-
-type SkinsRepository interface {
-	FindSkinByUsername(username string) (*model.Skin, error)
-	FindSkinByUserId(id int) (*model.Skin, error)
-	SaveSkin(skin *model.Skin) error
-	RemoveSkinByUserId(id int) error
-	RemoveSkinByUsername(username string) error
-}
-
-type CapesRepository interface {
-	FindCapeByUsername(username string) (*model.Cape, error)
-}
-
-type MojangTexturesProvider interface {
-	GetForUsername(username string) (*mojang.SignedTexturesResponse, error)
-}
-
-type Skinsystem struct {
-	Emitter
-	SkinsRepo               SkinsRepository
-	CapesRepo               CapesRepository
-	MojangTexturesProvider  MojangTexturesProvider
-	TexturesExtraParamName  string
-	TexturesExtraParamValue string
-}
-
-func (ctx *Skinsystem) Handler() *mux.Router {
-	router := mux.NewRouter().StrictSlash(true)
-
-	router.HandleFunc("/skins/{username}", ctx.skinHandler).Methods(http.MethodGet)
-	router.HandleFunc("/cloaks/{username}", ctx.capeHandler).Methods(http.MethodGet).Name("cloaks")
-	router.HandleFunc("/textures/{username}", ctx.texturesHandler).Methods(http.MethodGet)
-	router.HandleFunc("/textures/signed/{username}", ctx.signedTexturesHandler).Methods(http.MethodGet)
-	// Legacy
-	router.HandleFunc("/skins", ctx.skinGetHandler).Methods(http.MethodGet)
-	router.HandleFunc("/cloaks", ctx.capeGetHandler).Methods(http.MethodGet)
-
-	return router
-}
-
-func (ctx *Skinsystem) skinHandler(response http.ResponseWriter, request *http.Request) {
-	username := parseUsername(mux.Vars(request)["username"])
-	rec, err := ctx.SkinsRepo.FindSkinByUsername(username)
-	if err == nil && rec != nil && rec.SkinId != 0 {
-		http.Redirect(response, request, rec.Url, 301)
-		return
-	}
-
-	mojangTextures, err := ctx.MojangTexturesProvider.GetForUsername(username)
-	if err != nil || mojangTextures == nil {
-		response.WriteHeader(http.StatusNotFound)
-		return
-	}
-
-	texturesProp := mojangTextures.DecodeTextures()
-	skin := texturesProp.Textures.Skin
-	if skin == nil {
-		response.WriteHeader(http.StatusNotFound)
-		return
-	}
-
-	http.Redirect(response, request, skin.Url, 301)
-}
-
-func (ctx *Skinsystem) skinGetHandler(response http.ResponseWriter, request *http.Request) {
-	username := request.URL.Query().Get("name")
-	if username == "" {
-		response.WriteHeader(http.StatusBadRequest)
-		return
-	}
-
-	mux.Vars(request)["username"] = username
-	mux.Vars(request)["converted"] = "1"
-
-	ctx.skinHandler(response, request)
-}
-
-func (ctx *Skinsystem) capeHandler(response http.ResponseWriter, request *http.Request) {
-	username := parseUsername(mux.Vars(request)["username"])
-	rec, err := ctx.CapesRepo.FindCapeByUsername(username)
-	if err == nil && rec != nil {
-		request.Header.Set("Content-Type", "image/png")
-		_, _ = io.Copy(response, rec.File)
-		return
-	}
-
-	mojangTextures, err := ctx.MojangTexturesProvider.GetForUsername(username)
-	if err != nil || mojangTextures == nil {
-		response.WriteHeader(http.StatusNotFound)
-		return
-	}
-
-	texturesProp := mojangTextures.DecodeTextures()
-	cape := texturesProp.Textures.Cape
-	if cape == nil {
-		response.WriteHeader(http.StatusNotFound)
-		return
-	}
-
-	http.Redirect(response, request, cape.Url, 301)
-}
-
-func (ctx *Skinsystem) capeGetHandler(response http.ResponseWriter, request *http.Request) {
-	username := request.URL.Query().Get("name")
-	if username == "" {
-		response.WriteHeader(http.StatusBadRequest)
-		return
-	}
-
-	mux.Vars(request)["username"] = username
-	mux.Vars(request)["converted"] = "1"
-
-	ctx.capeHandler(response, request)
-}
-
-func (ctx *Skinsystem) texturesHandler(response http.ResponseWriter, request *http.Request) {
-	username := parseUsername(mux.Vars(request)["username"])
-
-	var textures *mojang.TexturesResponse
-	skin, skinErr := ctx.SkinsRepo.FindSkinByUsername(username)
-	cape, capeErr := ctx.CapesRepo.FindCapeByUsername(username)
-	if (skinErr == nil && skin != nil && skin.SkinId != 0) || (capeErr == nil && cape != nil) {
-		textures = &mojang.TexturesResponse{}
-		if skinErr == nil && skin != nil && skin.SkinId != 0 {
-			skinTextures := &mojang.SkinTexturesResponse{
-				Url: skin.Url,
-			}
-
-			if skin.IsSlim {
-				skinTextures.Metadata = &mojang.SkinTexturesMetadata{
-					Model: "slim",
-				}
-			}
-
-			textures.Skin = skinTextures
-		}
-
-		if capeErr == nil && cape != nil {
-			textures.Cape = &mojang.CapeTexturesResponse{
-				// Use statically http since the application doesn't support TLS
-				Url: "http://" + request.Host + "/cloaks/" + username,
-			}
-		}
-	} else {
-		mojangTextures, err := ctx.MojangTexturesProvider.GetForUsername(username)
-		if err != nil || mojangTextures == nil {
-			response.WriteHeader(http.StatusNoContent)
-			return
-		}
-
-		texturesProp := mojangTextures.DecodeTextures()
-		if texturesProp == nil {
-			ctx.Emit("skinsystem:error", errors.New("unable to find textures property"))
-			apiServerError(response)
-			return
-		}
-
-		textures = texturesProp.Textures
-		if textures.Skin == nil && textures.Cape == nil {
-			response.WriteHeader(http.StatusNoContent)
-			return
-		}
-	}
-
-	responseData, _ := json.Marshal(textures)
-	response.Header().Set("Content-Type", "application/json")
-	_, _ = response.Write(responseData)
-}
-
-func (ctx *Skinsystem) signedTexturesHandler(response http.ResponseWriter, request *http.Request) {
-	username := parseUsername(mux.Vars(request)["username"])
-
-	var responseData *mojang.SignedTexturesResponse
-
-	rec, err := ctx.SkinsRepo.FindSkinByUsername(username)
-	if err == nil && rec != nil && rec.SkinId != 0 && rec.MojangTextures != "" {
-		responseData = &mojang.SignedTexturesResponse{
-			Id:   strings.Replace(rec.Uuid, "-", "", -1),
-			Name: rec.Username,
-			Props: []*mojang.Property{
-				{
-					Name:      "textures",
-					Signature: rec.MojangSignature,
-					Value:     rec.MojangTextures,
-				},
-			},
-		}
-	} else if request.URL.Query().Get("proxy") != "" {
-		mojangTextures, err := ctx.MojangTexturesProvider.GetForUsername(username)
-		if err == nil && mojangTextures != nil {
-			responseData = mojangTextures
-		}
-	}
-
-	if responseData == nil {
-		response.WriteHeader(http.StatusNoContent)
-		return
-	}
-
-	responseData.Props = append(responseData.Props, &mojang.Property{
-		Name:  ctx.TexturesExtraParamName,
-		Value: ctx.TexturesExtraParamValue,
-	})
-
-	responseJson, _ := json.Marshal(responseData)
-	response.Header().Set("Content-Type", "application/json")
-	_, _ = response.Write(responseJson)
-}
-
-func parseUsername(username string) string {
-	return strings.TrimSuffix(username, ".png")
-}
--- a/http/skinsystem_test.go
+++ b/http/skinsystem_test.go
@@ -1,702 +0,0 @@
-package http
-
-import (
-	"bytes"
-	"image"
-	"image/png"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	testify "github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/suite"
-
-	"github.com/elyby/chrly/api/mojang"
-	"github.com/elyby/chrly/model"
-)
-
-/***************
- * Setup mocks *
- ***************/
-
-type skinsRepositoryMock struct {
-	mock.Mock
-}
-
-func (m *skinsRepositoryMock) FindSkinByUsername(username string) (*model.Skin, error) {
-	args := m.Called(username)
-	var result *model.Skin
-	if casted, ok := args.Get(0).(*model.Skin); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-func (m *skinsRepositoryMock) FindSkinByUserId(id int) (*model.Skin, error) {
-	args := m.Called(id)
-	var result *model.Skin
-	if casted, ok := args.Get(0).(*model.Skin); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-func (m *skinsRepositoryMock) SaveSkin(skin *model.Skin) error {
-	args := m.Called(skin)
-	return args.Error(0)
-}
-
-func (m *skinsRepositoryMock) RemoveSkinByUserId(id int) error {
-	args := m.Called(id)
-	return args.Error(0)
-}
-
-func (m *skinsRepositoryMock) RemoveSkinByUsername(username string) error {
-	args := m.Called(username)
-	return args.Error(0)
-}
-
-type capesRepositoryMock struct {
-	mock.Mock
-}
-
-func (m *capesRepositoryMock) FindCapeByUsername(username string) (*model.Cape, error) {
-	args := m.Called(username)
-	var result *model.Cape
-	if casted, ok := args.Get(0).(*model.Cape); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-type mojangTexturesProviderMock struct {
-	mock.Mock
-}
-
-func (m *mojangTexturesProviderMock) GetForUsername(username string) (*mojang.SignedTexturesResponse, error) {
-	args := m.Called(username)
-	var result *mojang.SignedTexturesResponse
-	if casted, ok := args.Get(0).(*mojang.SignedTexturesResponse); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-type skinsystemTestSuite struct {
-	suite.Suite
-
-	App *Skinsystem
-
-	SkinsRepository        *skinsRepositoryMock
-	CapesRepository        *capesRepositoryMock
-	MojangTexturesProvider *mojangTexturesProviderMock
-	Emitter                *emitterMock
-}
-
-/********************
- * Setup test suite *
- ********************/
-
-func (suite *skinsystemTestSuite) SetupTest() {
-	suite.SkinsRepository = &skinsRepositoryMock{}
-	suite.CapesRepository = &capesRepositoryMock{}
-	suite.MojangTexturesProvider = &mojangTexturesProviderMock{}
-	suite.Emitter = &emitterMock{}
-
-	suite.App = &Skinsystem{
-		SkinsRepo:               suite.SkinsRepository,
-		CapesRepo:               suite.CapesRepository,
-		MojangTexturesProvider:  suite.MojangTexturesProvider,
-		Emitter:                 suite.Emitter,
-		TexturesExtraParamName:  "texturesParamName",
-		TexturesExtraParamValue: "texturesParamValue",
-	}
-}
-
-func (suite *skinsystemTestSuite) TearDownTest() {
-	suite.SkinsRepository.AssertExpectations(suite.T())
-	suite.CapesRepository.AssertExpectations(suite.T())
-	suite.MojangTexturesProvider.AssertExpectations(suite.T())
-	suite.Emitter.AssertExpectations(suite.T())
-}
-
-func (suite *skinsystemTestSuite) RunSubTest(name string, subTest func()) {
-	suite.SetupTest()
-	suite.Run(name, subTest)
-	suite.TearDownTest()
-}
-
-/*************
- * Run tests *
- *************/
-
-func TestSkinsystem(t *testing.T) {
-	suite.Run(t, new(skinsystemTestSuite))
-}
-
-type skinsystemTestCase struct {
-	Name       string
-	BeforeTest func(suite *skinsystemTestSuite)
-	AfterTest  func(suite *skinsystemTestSuite, response *http.Response)
-}
-
-/************************
- * Get skin tests cases *
- ************************/
-
-var skinsTestsCases = []*skinsystemTestCase{
-	{
-		Name: "Username exists in the local storage",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", false), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(301, response.StatusCode)
-			suite.Equal("http://chrly/skin.png", response.Header.Get("Location"))
-		},
-	},
-	{
-		Name: "Username doesn't exists on the local storage, but exists on Mojang and has textures",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Return(createMojangResponse(true, false), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(301, response.StatusCode)
-			suite.Equal("http://mojang/skin.png", response.Header.Get("Location"))
-		},
-	},
-	{
-		Name: "Username doesn't exists on the local storage, but exists on Mojang and has no textures",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Return(createMojangResponse(false, false), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(404, response.StatusCode)
-		},
-	},
-	{
-		Name: "Username doesn't exists on the local storage and doesn't exists on Mojang",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Return(nil, nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(404, response.StatusCode)
-		},
-	},
-}
-
-func (suite *skinsystemTestSuite) TestSkin() {
-	for _, testCase := range skinsTestsCases {
-		suite.RunSubTest(testCase.Name, func() {
-			testCase.BeforeTest(suite)
-
-			req := httptest.NewRequest("GET", "http://chrly/skins/mock_username", nil)
-			w := httptest.NewRecorder()
-
-			suite.App.Handler().ServeHTTP(w, req)
-
-			testCase.AfterTest(suite, w.Result())
-		})
-	}
-
-	suite.RunSubTest("Pass username with png extension", func() {
-		suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", false), nil)
-
-		req := httptest.NewRequest("GET", "http://chrly/skins/mock_username.png", nil)
-		w := httptest.NewRecorder()
-
-		suite.App.Handler().ServeHTTP(w, req)
-
-		resp := w.Result()
-		suite.Equal(301, resp.StatusCode)
-		suite.Equal("http://chrly/skin.png", resp.Header.Get("Location"))
-	})
-}
-
-func (suite *skinsystemTestSuite) TestSkinGET() {
-	for _, testCase := range skinsTestsCases {
-		suite.RunSubTest(testCase.Name, func() {
-			testCase.BeforeTest(suite)
-
-			req := httptest.NewRequest("GET", "http://chrly/skins?name=mock_username", nil)
-			w := httptest.NewRecorder()
-
-			suite.App.Handler().ServeHTTP(w, req)
-
-			testCase.AfterTest(suite, w.Result())
-		})
-	}
-
-	suite.RunSubTest("Do not pass name param", func() {
-
-		req := httptest.NewRequest("GET", "http://chrly/skins", nil)
-		w := httptest.NewRecorder()
-
-		suite.App.Handler().ServeHTTP(w, req)
-
-		resp := w.Result()
-		suite.Equal(400, resp.StatusCode)
-	})
-}
-
-/************************
- * Get cape tests cases *
- ************************/
-
-var capesTestsCases = []*skinsystemTestCase{
-	{
-		Name: "Username exists in the local storage",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(createCapeModel(), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(200, response.StatusCode)
-			responseData, _ := ioutil.ReadAll(response.Body)
-			suite.Equal(createCape(), responseData)
-			suite.Equal("image/png", response.Header.Get("Content-Type"))
-		},
-	},
-	{
-		Name: "Username doesn't exists on the local storage, but exists on Mojang and has textures",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Return(createMojangResponse(true, true), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(301, response.StatusCode)
-			suite.Equal("http://mojang/cape.png", response.Header.Get("Location"))
-		},
-	},
-	{
-		Name: "Username doesn't exists on the local storage, but exists on Mojang and has no textures",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Return(createMojangResponse(false, false), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(404, response.StatusCode)
-		},
-	},
-	{
-		Name: "Username doesn't exists on the local storage and doesn't exists on Mojang",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Return(nil, nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(404, response.StatusCode)
-		},
-	},
-}
-
-func (suite *skinsystemTestSuite) TestCape() {
-	for _, testCase := range capesTestsCases {
-		suite.RunSubTest(testCase.Name, func() {
-			testCase.BeforeTest(suite)
-
-			req := httptest.NewRequest("GET", "http://chrly/cloaks/mock_username", nil)
-			w := httptest.NewRecorder()
-
-			suite.App.Handler().ServeHTTP(w, req)
-
-			testCase.AfterTest(suite, w.Result())
-		})
-	}
-
-	suite.RunSubTest("Pass username with png extension", func() {
-		suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(createCapeModel(), nil)
-
-		req := httptest.NewRequest("GET", "http://chrly/cloaks/mock_username.png", nil)
-		w := httptest.NewRecorder()
-
-		suite.App.Handler().ServeHTTP(w, req)
-
-		resp := w.Result()
-		suite.Equal(200, resp.StatusCode)
-		responseData, _ := ioutil.ReadAll(resp.Body)
-		suite.Equal(createCape(), responseData)
-		suite.Equal("image/png", resp.Header.Get("Content-Type"))
-	})
-}
-
-func (suite *skinsystemTestSuite) TestCapeGET() {
-	for _, testCase := range capesTestsCases {
-		suite.RunSubTest(testCase.Name, func() {
-			testCase.BeforeTest(suite)
-
-			req := httptest.NewRequest("GET", "http://chrly/cloaks?name=mock_username", nil)
-			w := httptest.NewRecorder()
-
-			suite.App.Handler().ServeHTTP(w, req)
-
-			testCase.AfterTest(suite, w.Result())
-		})
-	}
-
-	suite.RunSubTest("Do not pass name param", func() {
-
-		req := httptest.NewRequest("GET", "http://chrly/cloaks", nil)
-		w := httptest.NewRecorder()
-
-		suite.App.Handler().ServeHTTP(w, req)
-
-		resp := w.Result()
-		suite.Equal(400, resp.StatusCode)
-	})
-}
-
-/****************************
- * Get textures tests cases *
- ****************************/
-
-var texturesTestsCases = []*skinsystemTestCase{
-	{
-		Name: "Username exists and has skin, no cape",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", false), nil)
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(nil, nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(200, response.StatusCode)
-			suite.Equal("application/json", response.Header.Get("Content-Type"))
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.JSONEq(`{
-				"SKIN": {
-					"url": "http://chrly/skin.png"
-				}
-			}`, string(body))
-		},
-	},
-	{
-		Name: "Username exists and has slim skin, no cape",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", true), nil)
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(nil, nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(200, response.StatusCode)
-			suite.Equal("application/json", response.Header.Get("Content-Type"))
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.JSONEq(`{
-				"SKIN": {
-					"url": "http://chrly/skin.png",
-					"metadata": {
-						"model": "slim"
-					}
-				}
-			}`, string(body))
-		},
-	},
-	{
-		Name: "Username exists and has cape, no skin",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(createCapeModel(), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(200, response.StatusCode)
-			suite.Equal("application/json", response.Header.Get("Content-Type"))
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.JSONEq(`{
-				"CAPE": {
-					"url": "http://chrly/cloaks/mock_username"
-				}
-			}`, string(body))
-		},
-	},
-	{
-		Name: "Username exists and has both skin and cape",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", false), nil)
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(createCapeModel(), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(200, response.StatusCode)
-			suite.Equal("application/json", response.Header.Get("Content-Type"))
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.JSONEq(`{
-				"SKIN": {
-					"url": "http://chrly/skin.png"
-				},
-				"CAPE": {
-					"url": "http://chrly/cloaks/mock_username"
-				}
-			}`, string(body))
-		},
-	},
-	{
-		Name: "Username not exists, but Mojang profile available",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Once().Return(createMojangResponse(true, true), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(200, response.StatusCode)
-			suite.Equal("application/json", response.Header.Get("Content-Type"))
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.JSONEq(`{
-				"SKIN": {
-					"url": "http://mojang/skin.png"
-				},
-				"CAPE": {
-					"url": "http://mojang/cape.png"
-				}
-			}`, string(body))
-		},
-	},
-	{
-		Name: "Username not exists, but Mojang profile available, but there is no textures",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Once().Return(createMojangResponse(false, false), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(204, response.StatusCode)
-		},
-	},
-	{
-		Name: "Username not exists and Mojang profile unavailable",
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.CapesRepository.On("FindCapeByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Once().Return(nil, nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(204, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Equal("", string(body))
-		},
-	},
-}
-
-func (suite *skinsystemTestSuite) TestTextures() {
-	for _, testCase := range texturesTestsCases {
-		suite.RunSubTest(testCase.Name, func() {
-			testCase.BeforeTest(suite)
-
-			req := httptest.NewRequest("GET", "http://chrly/textures/mock_username", nil)
-			w := httptest.NewRecorder()
-
-			suite.App.Handler().ServeHTTP(w, req)
-
-			testCase.AfterTest(suite, w.Result())
-		})
-	}
-}
-
-/***********************************
- * Get signed textures tests cases *
- ***********************************/
-
-type signedTexturesTestCase struct {
-	Name       string
-	AllowProxy bool
-	BeforeTest func(suite *skinsystemTestSuite)
-	AfterTest  func(suite *skinsystemTestSuite, response *http.Response)
-}
-
-var signedTexturesTestsCases = []*signedTexturesTestCase{
-	{
-		Name:       "Username exists",
-		AllowProxy: false,
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", true), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(200, response.StatusCode)
-			suite.Equal("application/json", response.Header.Get("Content-Type"))
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.JSONEq(`{
-				"id": "0f657aa8bfbe415db7005750090d3af3",
-				"name": "mock_username",
-				"properties": [
-					{
-						"name": "textures",
-						"signature": "mocked signature",
-						"value": "mocked textures base64"
-					},
-					{
-						"name": "texturesParamName",
-						"value": "texturesParamValue"
-					}
-				]
-			}`, string(body))
-		},
-	},
-	{
-		Name:       "Username not exists",
-		AllowProxy: false,
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(204, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Equal("", string(body))
-		},
-	},
-	{
-		Name:       "Username exists, but has no signed textures",
-		AllowProxy: false,
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			skinModel := createSkinModel("mock_username", true)
-			skinModel.MojangTextures = ""
-			skinModel.MojangSignature = ""
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(skinModel, nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(204, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Equal("", string(body))
-		},
-	},
-	{
-		Name:       "Username not exists, but Mojang profile is available and proxying is enabled",
-		AllowProxy: true,
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Return(createMojangResponse(true, false), nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(200, response.StatusCode)
-			suite.Equal("application/json", response.Header.Get("Content-Type"))
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.JSONEq(`{
-				"id": "00000000000000000000000000000000",
-				"name": "mock_username",
-				"properties": [
-					{
-						"name": "textures",
-						"value": "eyJ0aW1lc3RhbXAiOjE1NTYzOTg1NzIsInByb2ZpbGVJZCI6IjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIiwicHJvZmlsZU5hbWUiOiJtb2NrX3VzZXJuYW1lIiwidGV4dHVyZXMiOnsiU0tJTiI6eyJ1cmwiOiJodHRwOi8vbW9qYW5nL3NraW4ucG5nIn19fQ=="
-					},
-					{
-						"name": "texturesParamName",
-						"value": "texturesParamValue"
-					}
-				]
-			}`, string(body))
-		},
-	},
-	{
-		Name:       "Username not exists, Mojang profile is unavailable too and proxying is enabled",
-		AllowProxy: true,
-		BeforeTest: func(suite *skinsystemTestSuite) {
-			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
-			suite.MojangTexturesProvider.On("GetForUsername", "mock_username").Return(nil, nil)
-		},
-		AfterTest: func(suite *skinsystemTestSuite, response *http.Response) {
-			suite.Equal(204, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Equal("", string(body))
-		},
-	},
-}
-
-func (suite *skinsystemTestSuite) TestSignedTextures() {
-	for _, testCase := range signedTexturesTestsCases {
-		suite.RunSubTest(testCase.Name, func() {
-			testCase.BeforeTest(suite)
-
-			var target string
-			if testCase.AllowProxy {
-				target = "http://chrly/textures/signed/mock_username?proxy=true"
-			} else {
-				target = "http://chrly/textures/signed/mock_username"
-			}
-
-			req := httptest.NewRequest("GET", target, nil)
-			w := httptest.NewRecorder()
-
-			suite.App.Handler().ServeHTTP(w, req)
-
-			testCase.AfterTest(suite, w.Result())
-		})
-	}
-}
-
-/****************
- * Custom tests *
- ****************/
-
-func TestParseUsername(t *testing.T) {
-	assert := testify.New(t)
-	assert.Equal("test", parseUsername("test.png"), "Function should trim .png at end")
-	assert.Equal("test", parseUsername("test"), "Function should return string itself, if it not contains .png at end")
-}
-
-/*************
- * Utilities *
- *************/
-
-func createSkinModel(username string, isSlim bool) *model.Skin {
-	return &model.Skin{
-		UserId:          1,
-		Username:        username,
-		Uuid:            "0f657aa8-bfbe-415d-b700-5750090d3af3", // Use non nil UUID to pass validation in api tests
-		SkinId:          1,
-		Url:             "http://chrly/skin.png",
-		MojangTextures:  "mocked textures base64",
-		MojangSignature: "mocked signature",
-		IsSlim:          isSlim,
-	}
-}
-
-func createCape() []byte {
-	img := image.NewAlpha(image.Rect(0, 0, 64, 32))
-	writer := &bytes.Buffer{}
-	_ = png.Encode(writer, img)
-	pngBytes, _ := ioutil.ReadAll(writer)
-
-	return pngBytes
-}
-
-func createCapeModel() *model.Cape {
-	return &model.Cape{File: bytes.NewReader(createCape())}
-}
-
-func createMojangResponse(includeSkin bool, includeCape bool) *mojang.SignedTexturesResponse {
-	timeZone, _ := time.LoadLocation("Europe/Minsk")
-	textures := &mojang.TexturesProp{
-		Timestamp:   time.Date(2019, 4, 27, 23, 56, 12, 0, timeZone).Unix(),
-		ProfileID:   "00000000000000000000000000000000",
-		ProfileName: "mock_username",
-		Textures:    &mojang.TexturesResponse{},
-	}
-
-	if includeSkin {
-		textures.Textures.Skin = &mojang.SkinTexturesResponse{
-			Url: "http://mojang/skin.png",
-		}
-	}
-
-	if includeCape {
-		textures.Textures.Cape = &mojang.CapeTexturesResponse{
-			Url: "http://mojang/cape.png",
-		}
-	}
-
-	response := &mojang.SignedTexturesResponse{
-		Id:   "00000000000000000000000000000000",
-		Name: "mock_username",
-		Props: []*mojang.Property{
-			{
-				Name:  "textures",
-				Value: mojang.EncodeTextures(textures),
-			},
-		},
-	}
-
-	return response
-}
--- a/http/textures.go
+++ b/http/textures.go
@@ -0,0 +1,102 @@
+package http
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"io"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gorilla/mux"
+
+	"github.com/elyby/chrly/model"
+)
+
+type texturesResponse struct {
+	Skin *Skin `json:"SKIN"`
+	Cape *Cape `json:"CAPE,omitempty"`
+}
+
+type Skin struct {
+	Url      string        `json:"url"`
+	Hash     string        `json:"hash"`
+	Metadata *skinMetadata `json:"metadata,omitempty"`
+}
+
+type skinMetadata struct {
+	Model string `json:"model"`
+}
+
+type Cape struct {
+	Url  string `json:"url"`
+	Hash string `json:"hash"`
+}
+
+func (cfg *Config) Textures(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("textures.request", 1)
+	username := parseUsername(mux.Vars(request)["username"])
+
+	skin, err := cfg.SkinsRepo.FindByUsername(username)
+	if err != nil || skin.SkinId == 0 {
+		if skin == nil {
+			skin = &model.Skin{}
+		}
+
+		skin.Url = "http://skins.minecraft.net/MinecraftSkins/" + username + ".png"
+		skin.Hash = string(buildNonElyTexturesHash(username))
+	}
+
+	textures := texturesResponse{
+		Skin: &Skin{
+			Url:  skin.Url,
+			Hash: skin.Hash,
+		},
+	}
+
+	if skin.IsSlim {
+		textures.Skin.Metadata = &skinMetadata{
+			Model: "slim",
+		}
+	}
+
+	cape, err := cfg.CapesRepo.FindByUsername(username)
+	if err == nil {
+		var scheme string = "http://"
+		if request.TLS != nil {
+			scheme = "https://"
+		}
+
+		textures.Cape = &Cape{
+			Url:  scheme + request.Host + "/cloaks/" + username,
+			Hash: calculateCapeHash(cape),
+		}
+	}
+
+	responseData, _ := json.Marshal(textures)
+	response.Header().Set("Content-Type", "application/json")
+	response.Write(responseData)
+}
+
+func calculateCapeHash(cape *model.Cape) string {
+	hasher := md5.New()
+	io.Copy(hasher, cape.File)
+
+	return hex.EncodeToString(hasher.Sum(nil))
+}
+
+func buildNonElyTexturesHash(username string) string {
+	hour := getCurrentHour()
+	hasher := md5.New()
+	hasher.Write([]byte("non-ely-" + strconv.FormatInt(hour, 10) + "-" + username))
+
+	return hex.EncodeToString(hasher.Sum(nil))
+}
+
+var timeNow = time.Now
+
+func getCurrentHour() int64 {
+	n := timeNow()
+	return time.Date(n.Year(), n.Month(), n.Day(), n.Hour(), 0, 0, 0, time.UTC).Unix()
+}
--- a/http/textures_test.go
+++ b/http/textures_test.go
@@ -0,0 +1,166 @@
+package http
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/model"
+)
+
+func TestConfig_Textures(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	mocks.Capes.EXPECT().FindByUsername("mock_user").Return(nil, &db.CapeNotFoundError{"mock_user"})
+	mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"SKIN": {
+			"url": "http://ely.by/minecraft/skins/skin.png",
+			"hash": "55d2a8848764f5ff04012cdb093458bd"
+		}
+	}`, string(response))
+}
+
+func TestConfig_Textures2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", true), nil)
+	mocks.Capes.EXPECT().FindByUsername("mock_user").Return(nil, &db.CapeNotFoundError{"mock_user"})
+	mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"SKIN": {
+			"url": "http://ely.by/minecraft/skins/skin.png",
+			"hash": "55d2a8848764f5ff04012cdb093458bd",
+			"metadata": {
+				"model": "slim"
+			}
+		}
+	}`, string(response))
+}
+
+func TestConfig_Textures3(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	mocks.Capes.EXPECT().FindByUsername("mock_user").Return(&model.Cape{
+		File: bytes.NewReader(createCape()),
+	}, nil)
+	mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"SKIN": {
+			"url": "http://ely.by/minecraft/skins/skin.png",
+			"hash": "55d2a8848764f5ff04012cdb093458bd"
+		},
+		"CAPE": {
+			"url": "http://skinsystem.ely.by/cloaks/mock_user",
+			"hash": "424ff79dce9940af89c28ad80de8aaad"
+		}
+	}`, string(response))
+}
+
+func TestConfig_Textures4(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, mocks := setupMocks(ctrl)
+
+	mocks.Skins.EXPECT().FindByUsername("notch").Return(nil, &db.SkinNotFoundError{})
+	mocks.Capes.EXPECT().FindByUsername("notch").Return(nil, &db.CapeNotFoundError{})
+	mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+	timeNow = func() time.Time {
+		return time.Date(2017, time.August, 20, 0, 15, 54, 0, time.UTC)
+	}
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"SKIN": {
+			"url": "http://skins.minecraft.net/MinecraftSkins/notch.png",
+			"hash": "5923cf3f7fa170a279e4d7a9483cfc52"
+		}
+	}`, string(response))
+}
+
+func TestBuildNonElyTexturesHash(t *testing.T) {
+	assert := testify.New(t)
+	timeNow = func() time.Time {
+		return time.Date(2017, time.November, 30, 16, 15, 34, 0, time.UTC)
+	}
+
+	assert.Equal("686d788a5353cb636e8fdff727634d88", buildNonElyTexturesHash("username"), "Function should return fixed hash by username-time pair")
+	assert.Equal("fb876f761683a10accdb17d403cef64c", buildNonElyTexturesHash("another-username"), "Function should return fixed hash by username-time pair")
+
+	timeNow = func() time.Time {
+		return time.Date(2017, time.November, 30, 16, 20, 12, 0, time.UTC)
+	}
+
+	assert.Equal("686d788a5353cb636e8fdff727634d88", buildNonElyTexturesHash("username"), "Function should do not change it's value if hour the same")
+	assert.Equal("fb876f761683a10accdb17d403cef64c", buildNonElyTexturesHash("another-username"), "Function should return fixed hash by username-time pair")
+
+	timeNow = func() time.Time {
+		return time.Date(2017, time.November, 30, 17, 1, 3, 0, time.UTC)
+	}
+
+	assert.Equal("42277892fd24bc0ed86285b3bb8b8fad", buildNonElyTexturesHash("username"), "Function should change it's value if hour changed")
+}
--- a/http/uuids_worker.go
+++ b/http/uuids_worker.go
@@ -1,53 +0,0 @@
-package http
-
-import (
-	"encoding/json"
-	"net/http"
-
-	"github.com/gorilla/mux"
-
-	"github.com/elyby/chrly/api/mojang"
-)
-
-type MojangUuidsProvider interface {
-	GetUuid(username string) (*mojang.ProfileInfo, error)
-}
-
-type UUIDsWorker struct {
-	MojangUuidsProvider
-}
-
-func (ctx *UUIDsWorker) Handler() *mux.Router {
-	router := mux.NewRouter().StrictSlash(true)
-	router.Handle("/mojang-uuid/{username}", http.HandlerFunc(ctx.getUUIDHandler)).Methods("GET")
-
-	return router
-}
-
-func (ctx *UUIDsWorker) getUUIDHandler(response http.ResponseWriter, request *http.Request) {
-	username := mux.Vars(request)["username"]
-	profile, err := ctx.GetUuid(username)
-	if err != nil {
-		if _, ok := err.(*mojang.TooManyRequestsError); ok {
-			response.WriteHeader(http.StatusTooManyRequests)
-			return
-		}
-
-		response.Header().Set("Content-Type", "application/json")
-		response.WriteHeader(http.StatusInternalServerError)
-		result, _ := json.Marshal(map[string]interface{}{
-			"provider": err.Error(),
-		})
-		_, _ = response.Write(result)
-		return
-	}
-
-	if profile == nil {
-		response.WriteHeader(http.StatusNoContent)
-		return
-	}
-
-	response.Header().Set("Content-Type", "application/json")
-	responseData, _ := json.Marshal(profile)
-	_, _ = response.Write(responseData)
-}
--- a/http/uuids_worker_test.go
+++ b/http/uuids_worker_test.go
@@ -1,154 +0,0 @@
-package http
-
-import (
-	"errors"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/suite"
-
-	"github.com/elyby/chrly/api/mojang"
-)
-
-/***************
- * Setup mocks *
- ***************/
-
-type uuidsProviderMock struct {
-	mock.Mock
-}
-
-func (m *uuidsProviderMock) GetUuid(username string) (*mojang.ProfileInfo, error) {
-	args := m.Called(username)
-	var result *mojang.ProfileInfo
-	if casted, ok := args.Get(0).(*mojang.ProfileInfo); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-type uuidsWorkerTestSuite struct {
-	suite.Suite
-
-	App *UUIDsWorker
-
-	UuidsProvider *uuidsProviderMock
-}
-
-/********************
- * Setup test suite *
- ********************/
-
-func (suite *uuidsWorkerTestSuite) SetupTest() {
-	suite.UuidsProvider = &uuidsProviderMock{}
-
-	suite.App = &UUIDsWorker{
-		MojangUuidsProvider: suite.UuidsProvider,
-	}
-}
-
-func (suite *uuidsWorkerTestSuite) TearDownTest() {
-	suite.UuidsProvider.AssertExpectations(suite.T())
-}
-
-func (suite *uuidsWorkerTestSuite) RunSubTest(name string, subTest func()) {
-	suite.SetupTest()
-	suite.Run(name, subTest)
-	suite.TearDownTest()
-}
-
-/*************
- * Run tests *
- *************/
-
-func TestUUIDsWorker(t *testing.T) {
-	suite.Run(t, new(uuidsWorkerTestSuite))
-}
-
-type uuidsWorkerTestCase struct {
-	Name       string
-	BeforeTest func(suite *uuidsWorkerTestSuite)
-	AfterTest  func(suite *uuidsWorkerTestSuite, response *http.Response)
-}
-
-/************************
- * Get UUID tests cases *
- ************************/
-
-var getUuidTestsCases = []*uuidsWorkerTestCase{
-	{
-		Name: "Success provider response",
-		BeforeTest: func(suite *uuidsWorkerTestSuite) {
-			suite.UuidsProvider.On("GetUuid", "mock_username").Return(&mojang.ProfileInfo{
-				Id:   "0fcc38620f1845f3a54e1b523c1bd1c7",
-				Name: "mock_username",
-			}, nil)
-		},
-		AfterTest: func(suite *uuidsWorkerTestSuite, response *http.Response) {
-			suite.Equal(200, response.StatusCode)
-			suite.Equal("application/json", response.Header.Get("Content-Type"))
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.JSONEq(`{
-				"id": "0fcc38620f1845f3a54e1b523c1bd1c7",
-				"name": "mock_username"
-			}`, string(body))
-		},
-	},
-	{
-		Name: "Receive empty response from UUIDs provider",
-		BeforeTest: func(suite *uuidsWorkerTestSuite) {
-			suite.UuidsProvider.On("GetUuid", "mock_username").Return(nil, nil)
-		},
-		AfterTest: func(suite *uuidsWorkerTestSuite, response *http.Response) {
-			suite.Equal(204, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Assert().Empty(body)
-		},
-	},
-	{
-		Name: "Receive error from UUIDs provider",
-		BeforeTest: func(suite *uuidsWorkerTestSuite) {
-			err := errors.New("this is an error")
-			suite.UuidsProvider.On("GetUuid", "mock_username").Return(nil, err)
-		},
-		AfterTest: func(suite *uuidsWorkerTestSuite, response *http.Response) {
-			suite.Equal(500, response.StatusCode)
-			suite.Equal("application/json", response.Header.Get("Content-Type"))
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.JSONEq(`{
-				"provider": "this is an error"
-			}`, string(body))
-		},
-	},
-	{
-		Name: "Receive Too Many Requests from UUIDs provider",
-		BeforeTest: func(suite *uuidsWorkerTestSuite) {
-			err := &mojang.TooManyRequestsError{}
-			suite.UuidsProvider.On("GetUuid", "mock_username").Return(nil, err)
-		},
-		AfterTest: func(suite *uuidsWorkerTestSuite, response *http.Response) {
-			suite.Equal(429, response.StatusCode)
-			body, _ := ioutil.ReadAll(response.Body)
-			suite.Empty(body)
-		},
-	},
-}
-
-func (suite *uuidsWorkerTestSuite) TestGetUUID() {
-	for _, testCase := range getUuidTestsCases {
-		suite.RunSubTest(testCase.Name, func() {
-			testCase.BeforeTest(suite)
-
-			req := httptest.NewRequest("GET", "http://chrly/mojang-uuid/mock_username", nil)
-			w := httptest.NewRecorder()
-
-			suite.App.Handler().ServeHTTP(w, req)
-
-			testCase.AfterTest(suite, w.Result())
-		})
-	}
-}
--- a/interfaces/auth.go
+++ b/interfaces/auth.go
@@ -0,0 +1,7 @@
+package interfaces
+
+import "net/http"
+
+type AuthChecker interface {
+	Check(req *http.Request) error
+}
--- a/interfaces/mock_interfaces/mock_auth.go
+++ b/interfaces/mock_interfaces/mock_auth.go
@@ -0,0 +1,45 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: interfaces/auth.go
+
+package mock_interfaces
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	http "net/http"
+	reflect "reflect"
+)
+
+// MockAuthChecker is a mock of AuthChecker interface
+type MockAuthChecker struct {
+	ctrl     *gomock.Controller
+	recorder *MockAuthCheckerMockRecorder
+}
+
+// MockAuthCheckerMockRecorder is the mock recorder for MockAuthChecker
+type MockAuthCheckerMockRecorder struct {
+	mock *MockAuthChecker
+}
+
+// NewMockAuthChecker creates a new mock instance
+func NewMockAuthChecker(ctrl *gomock.Controller) *MockAuthChecker {
+	mock := &MockAuthChecker{ctrl: ctrl}
+	mock.recorder = &MockAuthCheckerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (_m *MockAuthChecker) EXPECT() *MockAuthCheckerMockRecorder {
+	return _m.recorder
+}
+
+// Check mocks base method
+func (_m *MockAuthChecker) Check(req *http.Request) error {
+	ret := _m.ctrl.Call(_m, "Check", req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Check indicates an expected call of Check
+func (_mr *MockAuthCheckerMockRecorder) Check(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Check", reflect.TypeOf((*MockAuthChecker)(nil).Check), arg0)
+}
--- a/interfaces/mock_interfaces/mock_interfaces.go
+++ b/interfaces/mock_interfaces/mock_interfaces.go
@@ -0,0 +1,131 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: interfaces/repositories.go
+
+package mock_interfaces
+
+import (
+	model "github.com/elyby/chrly/model"
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockSkinsRepository is a mock of SkinsRepository interface
+type MockSkinsRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockSkinsRepositoryMockRecorder
+}
+
+// MockSkinsRepositoryMockRecorder is the mock recorder for MockSkinsRepository
+type MockSkinsRepositoryMockRecorder struct {
+	mock *MockSkinsRepository
+}
+
+// NewMockSkinsRepository creates a new mock instance
+func NewMockSkinsRepository(ctrl *gomock.Controller) *MockSkinsRepository {
+	mock := &MockSkinsRepository{ctrl: ctrl}
+	mock.recorder = &MockSkinsRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (_m *MockSkinsRepository) EXPECT() *MockSkinsRepositoryMockRecorder {
+	return _m.recorder
+}
+
+// FindByUsername mocks base method
+func (_m *MockSkinsRepository) FindByUsername(username string) (*model.Skin, error) {
+	ret := _m.ctrl.Call(_m, "FindByUsername", username)
+	ret0, _ := ret[0].(*model.Skin)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FindByUsername indicates an expected call of FindByUsername
+func (_mr *MockSkinsRepositoryMockRecorder) FindByUsername(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "FindByUsername", reflect.TypeOf((*MockSkinsRepository)(nil).FindByUsername), arg0)
+}
+
+// FindByUserId mocks base method
+func (_m *MockSkinsRepository) FindByUserId(id int) (*model.Skin, error) {
+	ret := _m.ctrl.Call(_m, "FindByUserId", id)
+	ret0, _ := ret[0].(*model.Skin)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FindByUserId indicates an expected call of FindByUserId
+func (_mr *MockSkinsRepositoryMockRecorder) FindByUserId(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "FindByUserId", reflect.TypeOf((*MockSkinsRepository)(nil).FindByUserId), arg0)
+}
+
+// Save mocks base method
+func (_m *MockSkinsRepository) Save(skin *model.Skin) error {
+	ret := _m.ctrl.Call(_m, "Save", skin)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Save indicates an expected call of Save
+func (_mr *MockSkinsRepositoryMockRecorder) Save(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Save", reflect.TypeOf((*MockSkinsRepository)(nil).Save), arg0)
+}
+
+// RemoveByUserId mocks base method
+func (_m *MockSkinsRepository) RemoveByUserId(id int) error {
+	ret := _m.ctrl.Call(_m, "RemoveByUserId", id)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RemoveByUserId indicates an expected call of RemoveByUserId
+func (_mr *MockSkinsRepositoryMockRecorder) RemoveByUserId(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "RemoveByUserId", reflect.TypeOf((*MockSkinsRepository)(nil).RemoveByUserId), arg0)
+}
+
+// RemoveByUsername mocks base method
+func (_m *MockSkinsRepository) RemoveByUsername(username string) error {
+	ret := _m.ctrl.Call(_m, "RemoveByUsername", username)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RemoveByUsername indicates an expected call of RemoveByUsername
+func (_mr *MockSkinsRepositoryMockRecorder) RemoveByUsername(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "RemoveByUsername", reflect.TypeOf((*MockSkinsRepository)(nil).RemoveByUsername), arg0)
+}
+
+// MockCapesRepository is a mock of CapesRepository interface
+type MockCapesRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockCapesRepositoryMockRecorder
+}
+
+// MockCapesRepositoryMockRecorder is the mock recorder for MockCapesRepository
+type MockCapesRepositoryMockRecorder struct {
+	mock *MockCapesRepository
+}
+
+// NewMockCapesRepository creates a new mock instance
+func NewMockCapesRepository(ctrl *gomock.Controller) *MockCapesRepository {
+	mock := &MockCapesRepository{ctrl: ctrl}
+	mock.recorder = &MockCapesRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (_m *MockCapesRepository) EXPECT() *MockCapesRepositoryMockRecorder {
+	return _m.recorder
+}
+
+// FindByUsername mocks base method
+func (_m *MockCapesRepository) FindByUsername(username string) (*model.Cape, error) {
+	ret := _m.ctrl.Call(_m, "FindByUsername", username)
+	ret0, _ := ret[0].(*model.Cape)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FindByUsername indicates an expected call of FindByUsername
+func (_mr *MockCapesRepositoryMockRecorder) FindByUsername(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "FindByUsername", reflect.TypeOf((*MockCapesRepository)(nil).FindByUsername), arg0)
+}
--- a/interfaces/mock_wd/mock_wd.go
+++ b/interfaces/mock_wd/mock_wd.go
@@ -0,0 +1,218 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/mono83/slf/wd (interfaces: Watchdog)
+
+package mock_wd
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	slf "github.com/mono83/slf"
+	wd "github.com/mono83/slf/wd"
+	reflect "reflect"
+	time "time"
+)
+
+// MockWatchdog is a mock of Watchdog interface
+type MockWatchdog struct {
+	ctrl     *gomock.Controller
+	recorder *MockWatchdogMockRecorder
+}
+
+// MockWatchdogMockRecorder is the mock recorder for MockWatchdog
+type MockWatchdogMockRecorder struct {
+	mock *MockWatchdog
+}
+
+// NewMockWatchdog creates a new mock instance
+func NewMockWatchdog(ctrl *gomock.Controller) *MockWatchdog {
+	mock := &MockWatchdog{ctrl: ctrl}
+	mock.recorder = &MockWatchdogMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (_m *MockWatchdog) EXPECT() *MockWatchdogMockRecorder {
+	return _m.recorder
+}
+
+// Alert mocks base method
+func (_m *MockWatchdog) Alert(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Alert", _s...)
+}
+
+// Alert indicates an expected call of Alert
+func (_mr *MockWatchdogMockRecorder) Alert(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Alert", reflect.TypeOf((*MockWatchdog)(nil).Alert), _s...)
+}
+
+// Debug mocks base method
+func (_m *MockWatchdog) Debug(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Debug", _s...)
+}
+
+// Debug indicates an expected call of Debug
+func (_mr *MockWatchdogMockRecorder) Debug(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Debug", reflect.TypeOf((*MockWatchdog)(nil).Debug), _s...)
+}
+
+// Emergency mocks base method
+func (_m *MockWatchdog) Emergency(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Emergency", _s...)
+}
+
+// Emergency indicates an expected call of Emergency
+func (_mr *MockWatchdogMockRecorder) Emergency(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Emergency", reflect.TypeOf((*MockWatchdog)(nil).Emergency), _s...)
+}
+
+// Error mocks base method
+func (_m *MockWatchdog) Error(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Error", _s...)
+}
+
+// Error indicates an expected call of Error
+func (_mr *MockWatchdogMockRecorder) Error(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Error", reflect.TypeOf((*MockWatchdog)(nil).Error), _s...)
+}
+
+// IncCounter mocks base method
+func (_m *MockWatchdog) IncCounter(_param0 string, _param1 int64, _param2 ...slf.Param) {
+	_s := []interface{}{_param0, _param1}
+	for _, _x := range _param2 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "IncCounter", _s...)
+}
+
+// IncCounter indicates an expected call of IncCounter
+func (_mr *MockWatchdogMockRecorder) IncCounter(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0, arg1}, arg2...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "IncCounter", reflect.TypeOf((*MockWatchdog)(nil).IncCounter), _s...)
+}
+
+// Info mocks base method
+func (_m *MockWatchdog) Info(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Info", _s...)
+}
+
+// Info indicates an expected call of Info
+func (_mr *MockWatchdogMockRecorder) Info(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Info", reflect.TypeOf((*MockWatchdog)(nil).Info), _s...)
+}
+
+// RecordTimer mocks base method
+func (_m *MockWatchdog) RecordTimer(_param0 string, _param1 time.Duration, _param2 ...slf.Param) {
+	_s := []interface{}{_param0, _param1}
+	for _, _x := range _param2 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "RecordTimer", _s...)
+}
+
+// RecordTimer indicates an expected call of RecordTimer
+func (_mr *MockWatchdogMockRecorder) RecordTimer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0, arg1}, arg2...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "RecordTimer", reflect.TypeOf((*MockWatchdog)(nil).RecordTimer), _s...)
+}
+
+// Timer mocks base method
+func (_m *MockWatchdog) Timer(_param0 string, _param1 ...slf.Param) slf.Timer {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	ret := _m.ctrl.Call(_m, "Timer", _s...)
+	ret0, _ := ret[0].(slf.Timer)
+	return ret0
+}
+
+// Timer indicates an expected call of Timer
+func (_mr *MockWatchdogMockRecorder) Timer(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Timer", reflect.TypeOf((*MockWatchdog)(nil).Timer), _s...)
+}
+
+// Trace mocks base method
+func (_m *MockWatchdog) Trace(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Trace", _s...)
+}
+
+// Trace indicates an expected call of Trace
+func (_mr *MockWatchdogMockRecorder) Trace(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Trace", reflect.TypeOf((*MockWatchdog)(nil).Trace), _s...)
+}
+
+// UpdateGauge mocks base method
+func (_m *MockWatchdog) UpdateGauge(_param0 string, _param1 int64, _param2 ...slf.Param) {
+	_s := []interface{}{_param0, _param1}
+	for _, _x := range _param2 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "UpdateGauge", _s...)
+}
+
+// UpdateGauge indicates an expected call of UpdateGauge
+func (_mr *MockWatchdogMockRecorder) UpdateGauge(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0, arg1}, arg2...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "UpdateGauge", reflect.TypeOf((*MockWatchdog)(nil).UpdateGauge), _s...)
+}
+
+// Warning mocks base method
+func (_m *MockWatchdog) Warning(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Warning", _s...)
+}
+
+// Warning indicates an expected call of Warning
+func (_mr *MockWatchdogMockRecorder) Warning(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Warning", reflect.TypeOf((*MockWatchdog)(nil).Warning), _s...)
+}
+
+// WithParams mocks base method
+func (_m *MockWatchdog) WithParams(_param0 ...slf.Param) wd.Watchdog {
+	_s := []interface{}{}
+	for _, _x := range _param0 {
+		_s = append(_s, _x)
+	}
+	ret := _m.ctrl.Call(_m, "WithParams", _s...)
+	ret0, _ := ret[0].(wd.Watchdog)
+	return ret0
+}
+
+// WithParams indicates an expected call of WithParams
+func (_mr *MockWatchdogMockRecorder) WithParams(arg0 ...interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "WithParams", reflect.TypeOf((*MockWatchdog)(nil).WithParams), arg0...)
+}
--- a/interfaces/repositories.go
+++ b/interfaces/repositories.go
@@ -0,0 +1,17 @@
+package interfaces
+
+import (
+	"github.com/elyby/chrly/model"
+)
+
+type SkinsRepository interface {
+	FindByUsername(username string) (*model.Skin, error)
+	FindByUserId(id int) (*model.Skin, error)
+	Save(skin *model.Skin) error
+	RemoveByUserId(id int) error
+	RemoveByUsername(username string) error
+}
+
+type CapesRepository interface {
+	FindByUsername(username string) (*model.Cape, error)
+}
--- a/model/skin.go
+++ b/model/skin.go
@@ -8,6 +8,7 @@ type Skin struct {
 	Url             string `json:"url"`
 	Is1_8           bool   `json:"is1_8"`
 	IsSlim          bool   `json:"isSlim"`
+	Hash            string `json:"hash"`
 	MojangTextures  string `json:"mojangTextures"`
 	MojangSignature string `json:"mojangSignature"`
 	OldUsername     string
--- a/mojangtextures/batch_uuids_provider.go
+++ b/mojangtextures/batch_uuids_provider.go
@@ -1,139 +0,0 @@
-package mojangtextures
-
-import (
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/elyby/chrly/api/mojang"
-)
-
-type jobResult struct {
-	profile *mojang.ProfileInfo
-	error   error
-}
-
-type jobItem struct {
-	username    string
-	respondChan chan *jobResult
-}
-
-type jobsQueue struct {
-	lock  sync.Mutex
-	items []*jobItem
-}
-
-func (s *jobsQueue) New() *jobsQueue {
-	s.items = []*jobItem{}
-	return s
-}
-
-func (s *jobsQueue) Enqueue(t *jobItem) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.items = append(s.items, t)
-}
-
-func (s *jobsQueue) Dequeue(n int) []*jobItem {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	if n > s.size() {
-		n = s.size()
-	}
-
-	items := s.items[0:n]
-	s.items = s.items[n:len(s.items)]
-
-	return items
-}
-
-func (s *jobsQueue) Size() int {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	return s.size()
-}
-
-func (s *jobsQueue) size() int {
-	return len(s.items)
-}
-
-var usernamesToUuids = mojang.UsernamesToUuids
-var forever = func() bool {
-	return true
-}
-
-type BatchUuidsProvider struct {
-	Emitter
-
-	IterationDelay time.Duration
-	IterationSize  int
-
-	onFirstCall sync.Once
-	queue       jobsQueue
-}
-
-func (ctx *BatchUuidsProvider) GetUuid(username string) (*mojang.ProfileInfo, error) {
-	ctx.onFirstCall.Do(func() {
-		ctx.queue.New()
-		ctx.startQueue()
-	})
-
-	resultChan := make(chan *jobResult)
-	ctx.queue.Enqueue(&jobItem{username, resultChan})
-	ctx.Emit("mojang_textures:batch_uuids_provider:queued", username)
-
-	result := <-resultChan
-
-	return result.profile, result.error
-}
-
-func (ctx *BatchUuidsProvider) startQueue() {
-	go func() {
-		time.Sleep(ctx.IterationDelay)
-		for forever() {
-			ctx.Emit("mojang_textures:batch_uuids_provider:before_round")
-			ctx.queueRound()
-			ctx.Emit("mojang_textures:batch_uuids_provider:after_round")
-			time.Sleep(ctx.IterationDelay)
-		}
-	}()
-}
-
-func (ctx *BatchUuidsProvider) queueRound() {
-	queueSize := ctx.queue.Size()
-	jobs := ctx.queue.Dequeue(ctx.IterationSize)
-
-	var usernames []string
-	for _, job := range jobs {
-		usernames = append(usernames, job.username)
-	}
-
-	ctx.Emit("mojang_textures:batch_uuids_provider:round", usernames, queueSize-len(jobs))
-	if len(usernames) == 0 {
-		return
-	}
-
-	profiles, err := usernamesToUuids(usernames)
-	ctx.Emit("mojang_textures:batch_uuids_provider:result", usernames, profiles, err)
-	for _, job := range jobs {
-		go func(job *jobItem) {
-			response := &jobResult{}
-			if err != nil {
-				response.error = err
-			} else {
-				// The profiles in the response aren't ordered, so we must search each username over full array
-				for _, profile := range profiles {
-					if strings.EqualFold(job.username, profile.Name) {
-						response.profile = profile
-						break
-					}
-				}
-			}
-
-			job.respondChan <- response
-		}(job)
-	}
-}
--- a/mojangtextures/batch_uuids_provider_test.go
+++ b/mojangtextures/batch_uuids_provider_test.go
@@ -1,300 +0,0 @@
-package mojangtextures
-
-import (
-	"crypto/rand"
-	"encoding/base64"
-	"strings"
-	"testing"
-
-	testify "github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/suite"
-
-	"github.com/elyby/chrly/api/mojang"
-)
-
-func TestJobsQueue(t *testing.T) {
-	createQueue := func() *jobsQueue {
-		queue := &jobsQueue{}
-		queue.New()
-
-		return queue
-	}
-
-	t.Run("Enqueue", func(t *testing.T) {
-		assert := testify.New(t)
-
-		s := createQueue()
-		s.Enqueue(&jobItem{username: "username1"})
-		s.Enqueue(&jobItem{username: "username2"})
-		s.Enqueue(&jobItem{username: "username3"})
-
-		assert.Equal(3, s.Size())
-	})
-
-	t.Run("Dequeue", func(t *testing.T) {
-		assert := testify.New(t)
-
-		s := createQueue()
-		s.Enqueue(&jobItem{username: "username1"})
-		s.Enqueue(&jobItem{username: "username2"})
-		s.Enqueue(&jobItem{username: "username3"})
-		s.Enqueue(&jobItem{username: "username4"})
-
-		items := s.Dequeue(2)
-		assert.Len(items, 2)
-		assert.Equal("username1", items[0].username)
-		assert.Equal("username2", items[1].username)
-		assert.Equal(2, s.Size())
-
-		items = s.Dequeue(40)
-		assert.Len(items, 2)
-		assert.Equal("username3", items[0].username)
-		assert.Equal("username4", items[1].username)
-	})
-}
-
-// This is really stupid test just to get 100% coverage on this package :)
-func TestBatchUuidsProvider_forever(t *testing.T) {
-	testify.True(t, forever())
-}
-
-type mojangUsernamesToUuidsRequestMock struct {
-	mock.Mock
-}
-
-func (o *mojangUsernamesToUuidsRequestMock) UsernamesToUuids(usernames []string) ([]*mojang.ProfileInfo, error) {
-	args := o.Called(usernames)
-	var result []*mojang.ProfileInfo
-	if casted, ok := args.Get(0).([]*mojang.ProfileInfo); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-type batchUuidsProviderGetUuidResult struct {
-	Result *mojang.ProfileInfo
-	Error  error
-}
-
-type batchUuidsProviderTestSuite struct {
-	suite.Suite
-
-	Provider     *BatchUuidsProvider
-	GetUuidAsync func(username string) chan *batchUuidsProviderGetUuidResult
-
-	Emitter   *mockEmitter
-	MojangApi *mojangUsernamesToUuidsRequestMock
-
-	Iterate     func()
-	done        func()
-	iterateChan chan bool
-}
-
-func (suite *batchUuidsProviderTestSuite) SetupTest() {
-	suite.Emitter = &mockEmitter{}
-
-	suite.Provider = &BatchUuidsProvider{
-		Emitter:        suite.Emitter,
-		IterationDelay: 0,
-		IterationSize:  10,
-	}
-
-	suite.iterateChan = make(chan bool)
-	forever = func() bool {
-		return <-suite.iterateChan
-	}
-
-	suite.Iterate = func() {
-		suite.iterateChan <- true
-	}
-
-	suite.done = func() {
-		suite.iterateChan <- false
-	}
-
-	suite.GetUuidAsync = func(username string) chan *batchUuidsProviderGetUuidResult {
-		s := make(chan bool)
-		// This dirty hack ensures, that the username will be queued before we return control to the caller.
-		// It's needed to keep expected calls order and prevent cases when iteration happens before all usernames
-		// will be queued.
-		suite.Emitter.On("Emit",
-			"mojang_textures:batch_uuids_provider:queued",
-			username,
-		).Once().Run(func(args mock.Arguments) {
-			s <- true
-		})
-
-		c := make(chan *batchUuidsProviderGetUuidResult)
-		go func() {
-			profile, err := suite.Provider.GetUuid(username)
-			c <- &batchUuidsProviderGetUuidResult{
-				Result: profile,
-				Error:  err,
-			}
-		}()
-
-		<-s
-
-		return c
-	}
-
-	suite.MojangApi = &mojangUsernamesToUuidsRequestMock{}
-	usernamesToUuids = suite.MojangApi.UsernamesToUuids
-}
-
-func (suite *batchUuidsProviderTestSuite) TearDownTest() {
-	suite.done()
-	suite.Emitter.AssertExpectations(suite.T())
-	suite.MojangApi.AssertExpectations(suite.T())
-}
-
-func TestBatchUuidsProvider(t *testing.T) {
-	suite.Run(t, new(batchUuidsProviderTestSuite))
-}
-
-func (suite *batchUuidsProviderTestSuite) TestGetUuidForOneUsername() {
-	expectedUsernames := []string{"username"}
-	expectedResult := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
-	expectedResponse := []*mojang.ProfileInfo{expectedResult}
-
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:before_round").Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:round", expectedUsernames, 0).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:result", expectedUsernames, expectedResponse, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:after_round").Once()
-
-	suite.MojangApi.On("UsernamesToUuids", expectedUsernames).Once().Return([]*mojang.ProfileInfo{expectedResult}, nil)
-
-	resultChan := suite.GetUuidAsync("username")
-
-	suite.Iterate()
-
-	result := <-resultChan
-	suite.Assert().Equal(expectedResult, result.Result)
-	suite.Assert().Nil(result.Error)
-}
-
-func (suite *batchUuidsProviderTestSuite) TestGetUuidForTwoUsernames() {
-	expectedUsernames := []string{"username1", "username2"}
-	expectedResult1 := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username1"}
-	expectedResult2 := &mojang.ProfileInfo{Id: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Name: "username2"}
-	expectedResponse := []*mojang.ProfileInfo{expectedResult1, expectedResult2}
-
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:before_round").Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:round", expectedUsernames, 0).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:result", expectedUsernames, expectedResponse, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:after_round").Once()
-
-	suite.MojangApi.On("UsernamesToUuids", expectedUsernames).Once().Return([]*mojang.ProfileInfo{
-		expectedResult1,
-		expectedResult2,
-	}, nil)
-
-	resultChan1 := suite.GetUuidAsync("username1")
-	resultChan2 := suite.GetUuidAsync("username2")
-
-	suite.Iterate()
-
-	result1 := <-resultChan1
-	suite.Assert().Equal(expectedResult1, result1.Result)
-	suite.Assert().Nil(result1.Error)
-
-	result2 := <-resultChan2
-	suite.Assert().Equal(expectedResult2, result2.Result)
-	suite.Assert().Nil(result2.Error)
-}
-
-func (suite *batchUuidsProviderTestSuite) TestGetUuidForMoreThan10Usernames() {
-	usernames := make([]string, 12)
-	for i := 0; i < cap(usernames); i++ {
-		usernames[i] = randStr(8)
-	}
-
-	// In this test we're not testing response, so always return an empty resultset
-	expectedResponse := []*mojang.ProfileInfo{}
-
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:before_round").Twice()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:round", usernames[0:10], 2).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:result", usernames[0:10], expectedResponse, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:round", usernames[10:12], 0).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:result", usernames[10:12], expectedResponse, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:after_round").Twice()
-
-	suite.MojangApi.On("UsernamesToUuids", usernames[0:10]).Once().Return(expectedResponse, nil)
-	suite.MojangApi.On("UsernamesToUuids", usernames[10:12]).Once().Return(expectedResponse, nil)
-
-	channels := make([]chan *batchUuidsProviderGetUuidResult, len(usernames))
-	for i, username := range usernames {
-		channels[i] = suite.GetUuidAsync(username)
-	}
-
-	suite.Iterate()
-	suite.Iterate()
-
-	for _, channel := range channels {
-		<-channel
-	}
-}
-
-func (suite *batchUuidsProviderTestSuite) TestDoNothingWhenNoTasks() {
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:before_round").Times(3)
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:round", []string{"username"}, 0).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:result", []string{"username"}, mock.Anything, nil).Once()
-	var nilStringSlice []string
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:round", nilStringSlice, 0).Twice()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:after_round").Times(3)
-
-	suite.MojangApi.On("UsernamesToUuids", []string{"username"}).Once().Return([]*mojang.ProfileInfo{}, nil)
-
-	// Perform first iteration and await it finishes
-	resultChan := suite.GetUuidAsync("username")
-
-	suite.Iterate()
-
-	result := <-resultChan
-	suite.Assert().Nil(result.Result)
-	suite.Assert().Nil(result.Error)
-
-	// Let it to perform a few more iterations to ensure, that there are no calls to external APIs
-	suite.Iterate()
-	suite.Iterate()
-}
-
-func (suite *batchUuidsProviderTestSuite) TestGetUuidForTwoUsernamesWithAnError() {
-	expectedUsernames := []string{"username1", "username2"}
-	expectedError := &mojang.TooManyRequestsError{}
-	var nilProfilesResponse []*mojang.ProfileInfo
-
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:before_round").Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:round", expectedUsernames, 0).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:result", expectedUsernames, nilProfilesResponse, expectedError).Once()
-	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:after_round").Once()
-
-	suite.MojangApi.On("UsernamesToUuids", expectedUsernames).Once().Return(nil, expectedError)
-
-	resultChan1 := suite.GetUuidAsync("username1")
-	resultChan2 := suite.GetUuidAsync("username2")
-
-	suite.Iterate()
-
-	result1 := <-resultChan1
-	suite.Assert().Nil(result1.Result)
-	suite.Assert().Equal(expectedError, result1.Error)
-
-	result2 := <-resultChan2
-	suite.Assert().Nil(result2.Result)
-	suite.Assert().Equal(expectedError, result2.Error)
-}
-
-var replacer = strings.NewReplacer("-", "_", "=", "")
-
-// https://stackoverflow.com/a/50581165
-func randStr(len int) string {
-	buff := make([]byte, len)
-	_, _ = rand.Read(buff)
-	str := replacer.Replace(base64.URLEncoding.EncodeToString(buff))
-
-	// Base 64 can be longer than len
-	return str[:len]
-}
--- a/mojangtextures/in_memory_textures_storage.go
+++ b/mojangtextures/in_memory_textures_storage.go
@@ -1,115 +0,0 @@
-package mojangtextures
-
-import (
-	"sync"
-	"time"
-
-	"github.com/elyby/chrly/api/mojang"
-
-	"github.com/tevino/abool"
-)
-
-var now = time.Now
-
-type inMemoryItem struct {
-	textures  *mojang.SignedTexturesResponse
-	timestamp int64
-}
-
-type InMemoryTexturesStorage struct {
-	GCPeriod time.Duration
-	Duration time.Duration
-
-	lock    sync.RWMutex
-	data    map[string]*inMemoryItem
-	working *abool.AtomicBool
-}
-
-func NewInMemoryTexturesStorage() *InMemoryTexturesStorage {
-	storage := &InMemoryTexturesStorage{
-		GCPeriod: 10 * time.Second,
-		Duration: time.Minute + 10*time.Second,
-		data:     make(map[string]*inMemoryItem),
-	}
-
-	return storage
-}
-
-func (s *InMemoryTexturesStorage) Start() {
-	if s.working == nil {
-		s.working = abool.New()
-	}
-
-	if !s.working.IsSet() {
-		go func() {
-			time.Sleep(s.GCPeriod)
-			// TODO: this can be reimplemented in future with channels, but right now I have no idea how to make it right
-			for s.working.IsSet() {
-				start := time.Now()
-				s.gc()
-				time.Sleep(s.GCPeriod - time.Since(start))
-			}
-		}()
-	}
-
-	s.working.Set()
-}
-
-func (s *InMemoryTexturesStorage) Stop() {
-	s.working.UnSet()
-}
-
-func (s *InMemoryTexturesStorage) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-
-	item, exists := s.data[uuid]
-	validRange := s.getMinimalNotExpiredTimestamp()
-	if !exists || validRange > item.timestamp {
-		return nil, &ValueNotFound{}
-	}
-
-	return item.textures, nil
-}
-
-func (s *InMemoryTexturesStorage) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
-	var timestamp int64
-	if textures != nil {
-		decoded := textures.DecodeTextures()
-		if decoded == nil {
-			panic("unable to decode textures")
-		}
-
-		timestamp = decoded.Timestamp
-	} else {
-		timestamp = unixNanoToUnixMicro(now().UnixNano())
-	}
-
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	s.data[uuid] = &inMemoryItem{
-		textures:  textures,
-		timestamp: timestamp,
-	}
-}
-
-func (s *InMemoryTexturesStorage) gc() {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	maxTime := s.getMinimalNotExpiredTimestamp()
-	for uuid, value := range s.data {
-		if maxTime > value.timestamp {
-			delete(s.data, uuid)
-		}
-	}
-}
-
-func (s *InMemoryTexturesStorage) getMinimalNotExpiredTimestamp() int64 {
-	return unixNanoToUnixMicro(now().Add(s.Duration * time.Duration(-1)).UnixNano())
-}
-
-func unixNanoToUnixMicro(unixNano int64) int64 {
-	return unixNano / 10e5
-}
--- a/mojangtextures/in_memory_textures_storage_test.go
+++ b/mojangtextures/in_memory_textures_storage_test.go
@@ -1,200 +0,0 @@
-package mojangtextures
-
-import (
-	"time"
-
-	"github.com/elyby/chrly/api/mojang"
-
-	testify "github.com/stretchr/testify/assert"
-	"testing"
-)
-
-var texturesWithSkin = &mojang.SignedTexturesResponse{
-	Id:   "dead24f9a4fa4877b7b04c8c6c72bb46",
-	Name: "mock",
-	Props: []*mojang.Property{
-		{
-			Name: "textures",
-			Value: mojang.EncodeTextures(&mojang.TexturesProp{
-				Timestamp:   time.Now().UnixNano() / 10e5,
-				ProfileID:   "dead24f9a4fa4877b7b04c8c6c72bb46",
-				ProfileName: "mock",
-				Textures: &mojang.TexturesResponse{
-					Skin: &mojang.SkinTexturesResponse{
-						Url: "http://textures.minecraft.net/texture/74d1e08b0bb7e9f590af27758125bbed1778ac6cef729aedfcb9613e9911ae75",
-					},
-				},
-			}),
-		},
-	},
-}
-var texturesWithoutSkin = &mojang.SignedTexturesResponse{
-	Id:   "dead24f9a4fa4877b7b04c8c6c72bb46",
-	Name: "mock",
-	Props: []*mojang.Property{
-		{
-			Name: "textures",
-			Value: mojang.EncodeTextures(&mojang.TexturesProp{
-				Timestamp:   time.Now().UnixNano() / 10e5,
-				ProfileID:   "dead24f9a4fa4877b7b04c8c6c72bb46",
-				ProfileName: "mock",
-				Textures:    &mojang.TexturesResponse{},
-			}),
-		},
-	},
-}
-
-func TestInMemoryTexturesStorage_GetTextures(t *testing.T) {
-	t.Run("get error when uuid is not exists", func(t *testing.T) {
-		assert := testify.New(t)
-
-		storage := NewInMemoryTexturesStorage()
-		result, err := storage.GetTextures("b5d58475007d4f9e9ddd1403e2497579")
-
-		assert.Nil(result)
-		assert.Error(err, "value not found in the storage")
-	})
-
-	t.Run("get textures object, when uuid is stored in the storage", func(t *testing.T) {
-		assert := testify.New(t)
-
-		storage := NewInMemoryTexturesStorage()
-		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
-		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
-
-		assert.Equal(texturesWithSkin, result)
-		assert.Nil(err)
-	})
-
-	t.Run("get error when uuid is exists, but textures are expired", func(t *testing.T) {
-		assert := testify.New(t)
-
-		storage := NewInMemoryTexturesStorage()
-		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
-
-		now = func() time.Time {
-			return time.Now().Add(time.Minute * 2)
-		}
-
-		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
-
-		assert.Nil(result)
-		assert.Error(err, "value not found in the storage")
-
-		now = time.Now
-	})
-}
-
-func TestInMemoryTexturesStorage_StoreTextures(t *testing.T) {
-	t.Run("store textures for previously not existed uuid", func(t *testing.T) {
-		assert := testify.New(t)
-
-		storage := NewInMemoryTexturesStorage()
-		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
-		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
-
-		assert.Equal(texturesWithSkin, result)
-		assert.Nil(err)
-	})
-
-	t.Run("override already existed textures for uuid", func(t *testing.T) {
-		assert := testify.New(t)
-
-		storage := NewInMemoryTexturesStorage()
-		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithoutSkin)
-		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
-		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
-
-		assert.NotEqual(texturesWithoutSkin, result)
-		assert.Equal(texturesWithSkin, result)
-		assert.Nil(err)
-	})
-
-	t.Run("store nil textures", func(t *testing.T) {
-		assert := testify.New(t)
-
-		storage := NewInMemoryTexturesStorage()
-		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", nil)
-		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
-
-		assert.Nil(result)
-		assert.Nil(err)
-	})
-
-	t.Run("should panic if textures prop is not decoded", func(t *testing.T) {
-		assert := testify.New(t)
-
-		toStore := &mojang.SignedTexturesResponse{
-			Id:    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-			Name:  "mock",
-			Props: []*mojang.Property{},
-		}
-
-		assert.PanicsWithValue("unable to decode textures", func() {
-			storage := NewInMemoryTexturesStorage()
-			storage.StoreTextures("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", toStore)
-		})
-	})
-}
-
-func TestInMemoryTexturesStorage_GarbageCollection(t *testing.T) {
-	assert := testify.New(t)
-
-	storage := NewInMemoryTexturesStorage()
-	storage.GCPeriod = 10 * time.Millisecond
-	storage.Duration = 10 * time.Millisecond
-
-	textures1 := &mojang.SignedTexturesResponse{
-		Id:   "dead24f9a4fa4877b7b04c8c6c72bb46",
-		Name: "mock1",
-		Props: []*mojang.Property{
-			{
-				Name: "textures",
-				Value: mojang.EncodeTextures(&mojang.TexturesProp{
-					Timestamp:   time.Now().Add(storage.GCPeriod-time.Millisecond*time.Duration(5)).UnixNano() / 10e5,
-					ProfileID:   "dead24f9a4fa4877b7b04c8c6c72bb46",
-					ProfileName: "mock1",
-					Textures:    &mojang.TexturesResponse{},
-				}),
-			},
-		},
-	}
-	textures2 := &mojang.SignedTexturesResponse{
-		Id:   "b5d58475007d4f9e9ddd1403e2497579",
-		Name: "mock2",
-		Props: []*mojang.Property{
-			{
-				Name: "textures",
-				Value: mojang.EncodeTextures(&mojang.TexturesProp{
-					Timestamp:   time.Now().Add(storage.GCPeriod-time.Millisecond*time.Duration(15)).UnixNano() / 10e5,
-					ProfileID:   "b5d58475007d4f9e9ddd1403e2497579",
-					ProfileName: "mock2",
-					Textures:    &mojang.TexturesResponse{},
-				}),
-			},
-		},
-	}
-
-	storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", textures1)
-	storage.StoreTextures("b5d58475007d4f9e9ddd1403e2497579", textures2)
-
-	storage.Start()
-
-	time.Sleep(storage.GCPeriod + time.Millisecond) // Let it start first iteration
-
-	_, textures1Err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
-	_, textures2Err := storage.GetTextures("b5d58475007d4f9e9ddd1403e2497579")
-
-	assert.Nil(textures1Err)
-	assert.Error(textures2Err)
-
-	time.Sleep(storage.GCPeriod + time.Millisecond) // Let another iteration happen
-
-	_, textures1Err = storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
-	_, textures2Err = storage.GetTextures("b5d58475007d4f9e9ddd1403e2497579")
-
-	assert.Error(textures1Err)
-	assert.Error(textures2Err)
-
-	storage.Stop()
-}
--- a/mojangtextures/mojang_api_textures_provider.go
+++ b/mojangtextures/mojang_api_textures_provider.go
@@ -1,19 +0,0 @@
-package mojangtextures
-
-import (
-	"github.com/elyby/chrly/api/mojang"
-)
-
-var uuidToTextures = mojang.UuidToTextures
-
-type MojangApiTexturesProvider struct {
-	Emitter
-}
-
-func (ctx *MojangApiTexturesProvider) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
-	ctx.Emit("mojang_textures:mojang_api_textures_provider:before_request", uuid)
-	result, err := uuidToTextures(uuid, true)
-	ctx.Emit("mojang_textures:mojang_api_textures_provider:after_request", result, err)
-
-	return result, err
-}
--- a/mojangtextures/mojang_api_textures_provider_test.go
+++ b/mojangtextures/mojang_api_textures_provider_test.go
@@ -1,96 +0,0 @@
-package mojangtextures
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/suite"
-
-	"github.com/elyby/chrly/api/mojang"
-)
-
-type mojangUuidToTexturesRequestMock struct {
-	mock.Mock
-}
-
-func (o *mojangUuidToTexturesRequestMock) UuidToTextures(uuid string, signed bool) (*mojang.SignedTexturesResponse, error) {
-	args := o.Called(uuid, signed)
-	var result *mojang.SignedTexturesResponse
-	if casted, ok := args.Get(0).(*mojang.SignedTexturesResponse); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-type mojangApiTexturesProviderTestSuite struct {
-	suite.Suite
-
-	Provider  *MojangApiTexturesProvider
-	Emitter   *mockEmitter
-	MojangApi *mojangUuidToTexturesRequestMock
-}
-
-func (suite *mojangApiTexturesProviderTestSuite) SetupTest() {
-	suite.Emitter = &mockEmitter{}
-	suite.MojangApi = &mojangUuidToTexturesRequestMock{}
-
-	suite.Provider = &MojangApiTexturesProvider{
-		Emitter: suite.Emitter,
-	}
-
-	uuidToTextures = suite.MojangApi.UuidToTextures
-}
-
-func (suite *mojangApiTexturesProviderTestSuite) TearDownTest() {
-	suite.MojangApi.AssertExpectations(suite.T())
-	suite.Emitter.AssertExpectations(suite.T())
-}
-
-func TestMojangApiTexturesProvider(t *testing.T) {
-	suite.Run(t, new(mojangApiTexturesProviderTestSuite))
-}
-
-func (suite *mojangApiTexturesProviderTestSuite) TestGetTextures() {
-	expectedResult := &mojang.SignedTexturesResponse{
-		Id:   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-		Name: "username",
-	}
-	suite.MojangApi.On("UuidToTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true).Once().Return(expectedResult, nil)
-
-	suite.Emitter.On("Emit",
-		"mojang_textures:mojang_api_textures_provider:before_request",
-		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-	).Once()
-	suite.Emitter.On("Emit",
-		"mojang_textures:mojang_api_textures_provider:after_request",
-		expectedResult,
-		nil,
-	).Once()
-
-	result, err := suite.Provider.GetTextures("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
-
-	suite.Assert().Equal(expectedResult, result)
-	suite.Assert().Nil(err)
-}
-
-func (suite *mojangApiTexturesProviderTestSuite) TestGetTexturesWithError() {
-	var expectedResponse *mojang.SignedTexturesResponse
-	expectedError := &mojang.TooManyRequestsError{}
-	suite.MojangApi.On("UuidToTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true).Once().Return(nil, expectedError)
-
-	suite.Emitter.On("Emit",
-		"mojang_textures:mojang_api_textures_provider:before_request",
-		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-	).Once()
-	suite.Emitter.On("Emit",
-		"mojang_textures:mojang_api_textures_provider:after_request",
-		expectedResponse,
-		expectedError,
-	).Once()
-
-	result, err := suite.Provider.GetTextures("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
-
-	suite.Assert().Nil(result)
-	suite.Assert().Equal(expectedError, err)
-}
--- a/mojangtextures/mojang_textures.go
+++ b/mojangtextures/mojang_textures.go
@@ -1,195 +0,0 @@
-package mojangtextures
-
-import (
-	"errors"
-	"regexp"
-	"strings"
-	"sync"
-
-	"github.com/elyby/chrly/api/mojang"
-	"github.com/elyby/chrly/dispatcher"
-)
-
-type broadcastResult struct {
-	textures *mojang.SignedTexturesResponse
-	error    error
-}
-
-type broadcaster struct {
-	lock      sync.Mutex
-	listeners map[string][]chan *broadcastResult
-}
-
-func createBroadcaster() *broadcaster {
-	return &broadcaster{
-		listeners: make(map[string][]chan *broadcastResult),
-	}
-}
-
-// Returns a boolean value, which will be true if the passed username didn't exist before
-func (c *broadcaster) AddListener(username string, resultChan chan *broadcastResult) bool {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	val, alreadyHasSource := c.listeners[username]
-	if alreadyHasSource {
-		c.listeners[username] = append(val, resultChan)
-		return false
-	}
-
-	c.listeners[username] = []chan *broadcastResult{resultChan}
-
-	return true
-}
-
-func (c *broadcaster) BroadcastAndRemove(username string, result *broadcastResult) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	val, ok := c.listeners[username]
-	if !ok {
-		return
-	}
-
-	for _, channel := range val {
-		go func(channel chan *broadcastResult) {
-			channel <- result
-			close(channel)
-		}(channel)
-	}
-
-	delete(c.listeners, username)
-}
-
-// https://help.mojang.com/customer/portal/articles/928638
-var allowedUsernamesRegex = regexp.MustCompile(`^[\w_]{3,16}$`)
-
-type UUIDsProvider interface {
-	GetUuid(username string) (*mojang.ProfileInfo, error)
-}
-
-type TexturesProvider interface {
-	GetTextures(uuid string) (*mojang.SignedTexturesResponse, error)
-}
-
-type Emitter interface {
-	dispatcher.Emitter
-}
-
-type Provider struct {
-	Emitter
-	UUIDsProvider
-	TexturesProvider
-	Storage
-
-	onFirstCall sync.Once
-	*broadcaster
-}
-
-func (ctx *Provider) GetForUsername(username string) (*mojang.SignedTexturesResponse, error) {
-	ctx.onFirstCall.Do(func() {
-		ctx.broadcaster = createBroadcaster()
-	})
-
-	if !allowedUsernamesRegex.MatchString(username) {
-		return nil, errors.New("invalid username")
-	}
-
-	username = strings.ToLower(username)
-	ctx.Emit("mojang_textures:call", username)
-
-	uuid, err := ctx.getUuidFromCache(username)
-	if err == nil && uuid == "" {
-		return nil, nil
-	}
-
-	if uuid != "" {
-		textures, err := ctx.getTexturesFromCache(uuid)
-		if err == nil {
-			return textures, nil
-		}
-	}
-
-	resultChan := make(chan *broadcastResult)
-	isFirstListener := ctx.broadcaster.AddListener(username, resultChan)
-	if isFirstListener {
-		go ctx.getResultAndBroadcast(username, uuid)
-	} else {
-		ctx.Emit("mojang_textures:already_processing", username)
-	}
-
-	result := <-resultChan
-
-	return result.textures, result.error
-}
-
-func (ctx *Provider) getResultAndBroadcast(username string, uuid string) {
-	ctx.Emit("mojang_textures:before_result", username, uuid)
-	result := ctx.getResult(username, uuid)
-	ctx.Emit("mojang_textures:after_result", username, result.textures, result.error)
-
-	ctx.broadcaster.BroadcastAndRemove(username, result)
-}
-
-func (ctx *Provider) getResult(username string, uuid string) *broadcastResult {
-	if uuid == "" {
-		profile, err := ctx.getUuid(username)
-		if err != nil {
-			return &broadcastResult{nil, err}
-		}
-
-		uuid = ""
-		if profile != nil {
-			uuid = profile.Id
-		}
-
-		_ = ctx.Storage.StoreUuid(username, uuid)
-
-		if uuid == "" {
-			return &broadcastResult{nil, nil}
-		}
-	}
-
-	textures, err := ctx.getTextures(uuid)
-	if err != nil {
-		return &broadcastResult{nil, err}
-	}
-
-	// Mojang can respond with an error, but it will still count as a hit,
-	// therefore store the result even if textures is nil to prevent 429 error
-	ctx.Storage.StoreTextures(uuid, textures)
-
-	return &broadcastResult{textures, nil}
-}
-
-func (ctx *Provider) getUuidFromCache(username string) (string, error) {
-	ctx.Emit("mojang_textures:usernames:before_cache", username)
-	uuid, err := ctx.Storage.GetUuid(username)
-	ctx.Emit("mojang_textures:usernames:after_cache", username, uuid, err)
-
-	return uuid, err
-}
-
-func (ctx *Provider) getTexturesFromCache(uuid string) (*mojang.SignedTexturesResponse, error) {
-	ctx.Emit("mojang_textures:textures:before_cache", uuid)
-	textures, err := ctx.Storage.GetTextures(uuid)
-	ctx.Emit("mojang_textures:textures:after_cache", uuid, textures, err)
-
-	return textures, err
-}
-
-func (ctx *Provider) getUuid(username string) (*mojang.ProfileInfo, error) {
-	ctx.Emit("mojang_textures:usernames:before_call", username)
-	profile, err := ctx.UUIDsProvider.GetUuid(username)
-	ctx.Emit("mojang_textures:usernames:after_call", username, profile, err)
-
-	return profile, err
-}
-
-func (ctx *Provider) getTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
-	ctx.Emit("mojang_textures:textures:before_call", uuid)
-	textures, err := ctx.TexturesProvider.GetTextures(uuid)
-	ctx.Emit("mojang_textures:textures:after_call", uuid, textures, err)
-
-	return textures, err
-}
--- a/mojangtextures/mojang_textures_test.go
+++ b/mojangtextures/mojang_textures_test.go
@@ -1,406 +0,0 @@
-package mojangtextures
-
-import (
-	"errors"
-	"sync"
-	"testing"
-	"time"
-
-	testify "github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/suite"
-
-	"github.com/elyby/chrly/api/mojang"
-)
-
-func TestBroadcaster(t *testing.T) {
-	t.Run("GetOrAppend", func(t *testing.T) {
-		t.Run("first call when username didn't exist before should return true", func(t *testing.T) {
-			assert := testify.New(t)
-
-			broadcaster := createBroadcaster()
-			channel := make(chan *broadcastResult)
-			isFirstListener := broadcaster.AddListener("mock", channel)
-
-			assert.True(isFirstListener)
-			listeners, ok := broadcaster.listeners["mock"]
-			assert.True(ok)
-			assert.Len(listeners, 1)
-			assert.Equal(channel, listeners[0])
-		})
-
-		t.Run("subsequent calls should return false", func(t *testing.T) {
-			assert := testify.New(t)
-
-			broadcaster := createBroadcaster()
-			channel1 := make(chan *broadcastResult)
-			isFirstListener := broadcaster.AddListener("mock", channel1)
-
-			assert.True(isFirstListener)
-
-			channel2 := make(chan *broadcastResult)
-			isFirstListener = broadcaster.AddListener("mock", channel2)
-
-			assert.False(isFirstListener)
-
-			channel3 := make(chan *broadcastResult)
-			isFirstListener = broadcaster.AddListener("mock", channel3)
-
-			assert.False(isFirstListener)
-		})
-	})
-
-	t.Run("BroadcastAndRemove", func(t *testing.T) {
-		t.Run("should broadcast to all listeners and remove the key", func(t *testing.T) {
-			assert := testify.New(t)
-
-			broadcaster := createBroadcaster()
-			channel1 := make(chan *broadcastResult)
-			channel2 := make(chan *broadcastResult)
-			broadcaster.AddListener("mock", channel1)
-			broadcaster.AddListener("mock", channel2)
-
-			result := &broadcastResult{}
-			broadcaster.BroadcastAndRemove("mock", result)
-
-			assert.Equal(result, <-channel1)
-			assert.Equal(result, <-channel2)
-
-			channel3 := make(chan *broadcastResult)
-			isFirstListener := broadcaster.AddListener("mock", channel3)
-			assert.True(isFirstListener)
-		})
-
-		t.Run("call on not exists username", func(t *testing.T) {
-			assert := testify.New(t)
-
-			assert.NotPanics(func() {
-				broadcaster := createBroadcaster()
-				broadcaster.BroadcastAndRemove("mock", &broadcastResult{})
-			})
-		})
-	})
-}
-
-type mockEmitter struct {
-	mock.Mock
-}
-
-func (e *mockEmitter) Emit(name string, args ...interface{}) {
-	e.Called(append([]interface{}{name}, args...)...)
-}
-
-type mockUuidsProvider struct {
-	mock.Mock
-}
-
-func (m *mockUuidsProvider) GetUuid(username string) (*mojang.ProfileInfo, error) {
-	args := m.Called(username)
-	var result *mojang.ProfileInfo
-	if casted, ok := args.Get(0).(*mojang.ProfileInfo); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-type mockTexturesProvider struct {
-	mock.Mock
-}
-
-func (m *mockTexturesProvider) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
-	args := m.Called(uuid)
-	var result *mojang.SignedTexturesResponse
-	if casted, ok := args.Get(0).(*mojang.SignedTexturesResponse); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-type mockStorage struct {
-	mock.Mock
-}
-
-func (m *mockStorage) GetUuid(username string) (string, error) {
-	args := m.Called(username)
-	return args.String(0), args.Error(1)
-}
-
-func (m *mockStorage) StoreUuid(username string, uuid string) error {
-	args := m.Called(username, uuid)
-	return args.Error(0)
-}
-
-func (m *mockStorage) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
-	args := m.Called(uuid)
-	var result *mojang.SignedTexturesResponse
-	if casted, ok := args.Get(0).(*mojang.SignedTexturesResponse); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-func (m *mockStorage) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
-	m.Called(uuid, textures)
-}
-
-type providerTestSuite struct {
-	suite.Suite
-	Provider         *Provider
-	Emitter          *mockEmitter
-	UuidsProvider    *mockUuidsProvider
-	TexturesProvider *mockTexturesProvider
-	Storage          *mockStorage
-}
-
-func (suite *providerTestSuite) SetupTest() {
-	suite.Emitter = &mockEmitter{}
-	suite.UuidsProvider = &mockUuidsProvider{}
-	suite.TexturesProvider = &mockTexturesProvider{}
-	suite.Storage = &mockStorage{}
-
-	suite.Provider = &Provider{
-		Emitter:          suite.Emitter,
-		UUIDsProvider:    suite.UuidsProvider,
-		TexturesProvider: suite.TexturesProvider,
-		Storage:          suite.Storage,
-	}
-}
-
-func (suite *providerTestSuite) TearDownTest() {
-	suite.Emitter.AssertExpectations(suite.T())
-	suite.UuidsProvider.AssertExpectations(suite.T())
-	suite.TexturesProvider.AssertExpectations(suite.T())
-	suite.Storage.AssertExpectations(suite.T())
-}
-
-func TestProvider(t *testing.T) {
-	suite.Run(t, new(providerTestSuite))
-}
-
-func (suite *providerTestSuite) TestGetForUsernameWithoutAnyCache() {
-	expectedProfile := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
-	expectedResult := &mojang.SignedTexturesResponse{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
-
-	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", &ValueNotFound{}).Once()
-	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
-
-	suite.Storage.On("GetUuid", "username").Once().Return("", &ValueNotFound{})
-	suite.Storage.On("StoreUuid", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil)
-	suite.Storage.On("StoreTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult).Once()
-
-	suite.UuidsProvider.On("GetUuid", "username").Once().Return(expectedProfile, nil)
-	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(expectedResult, nil)
-
-	result, err := suite.Provider.GetForUsername("username")
-
-	suite.Assert().Nil(err)
-	suite.Assert().Equal(expectedResult, result)
-}
-
-func (suite *providerTestSuite) TestGetForUsernameWithCachedUuid() {
-	var expectedCachedTextures *mojang.SignedTexturesResponse
-	expectedResult := &mojang.SignedTexturesResponse{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
-
-	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:before_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedCachedTextures, &ValueNotFound{}).Once()
-	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
-
-	suite.Storage.On("GetUuid", "username").Once().Return("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil)
-	suite.Storage.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil, &ValueNotFound{})
-	suite.Storage.On("StoreTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult).Once()
-
-	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Return(expectedResult, nil)
-
-	result, err := suite.Provider.GetForUsername("username")
-
-	suite.Assert().Nil(err)
-	suite.Assert().Equal(expectedResult, result)
-}
-
-func (suite *providerTestSuite) TestGetForUsernameWithFullyCachedResult() {
-	expectedResult := &mojang.SignedTexturesResponse{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
-
-	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:before_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
-
-	suite.Storage.On("GetUuid", "username").Once().Return("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil)
-	suite.Storage.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(expectedResult, nil)
-
-	result, err := suite.Provider.GetForUsername("username")
-
-	suite.Assert().Nil(err)
-	suite.Assert().Equal(expectedResult, result)
-}
-
-func (suite *providerTestSuite) TestGetForUsernameWithCachedUnknownUuid() {
-	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", nil).Once()
-
-	suite.Storage.On("GetUuid", "username").Once().Return("", nil)
-
-	result, err := suite.Provider.GetForUsername("username")
-
-	suite.Assert().Nil(result)
-	suite.Assert().Nil(err)
-}
-
-func (suite *providerTestSuite) TestGetForUsernameWhichHasNoMojangAccount() {
-	var expectedProfile *mojang.ProfileInfo
-	var expectedResult *mojang.SignedTexturesResponse
-
-	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", &ValueNotFound{}).Once()
-	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
-
-	suite.Storage.On("GetUuid", "username").Once().Return("", &ValueNotFound{})
-	suite.Storage.On("StoreUuid", "username", "").Once().Return(nil)
-
-	suite.UuidsProvider.On("GetUuid", "username").Once().Return(nil, nil)
-
-	result, err := suite.Provider.GetForUsername("username")
-
-	suite.Assert().Nil(err)
-	suite.Assert().Nil(result)
-}
-
-func (suite *providerTestSuite) TestGetForUsernameWhichHasMojangAccountButHasNoMojangSkin() {
-	expectedProfile := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
-	var expectedResult *mojang.SignedTexturesResponse
-
-	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", &ValueNotFound{}).Once()
-	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
-
-	suite.Storage.On("GetUuid", "username").Once().Return("", &ValueNotFound{})
-	suite.Storage.On("StoreUuid", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil)
-	suite.Storage.On("StoreTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult).Once()
-
-	suite.UuidsProvider.On("GetUuid", "username").Once().Return(expectedProfile, nil)
-	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(expectedResult, nil)
-
-	result, err := suite.Provider.GetForUsername("username")
-
-	suite.Assert().Equal(expectedResult, result)
-	suite.Assert().Nil(err)
-}
-
-func (suite *providerTestSuite) TestGetForTheSameUsernames() {
-	expectedProfile := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
-	expectedResult := &mojang.SignedTexturesResponse{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
-
-	suite.Emitter.On("Emit", "mojang_textures:call", "username").Twice()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Twice()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", &ValueNotFound{}).Twice()
-	suite.Emitter.On("Emit", "mojang_textures:already_processing", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
-
-	suite.Storage.On("GetUuid", "username").Twice().Return("", &ValueNotFound{})
-	suite.Storage.On("StoreUuid", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil)
-	suite.Storage.On("StoreTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult).Once()
-
-	// If possible, than remove this .After call
-	suite.UuidsProvider.On("GetUuid", "username").Once().After(time.Millisecond).Return(expectedProfile, nil)
-	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(expectedResult, nil)
-
-	results := make([]*mojang.SignedTexturesResponse, 2)
-	var wg sync.WaitGroup
-	for i := 0; i < 2; i++ {
-		wg.Add(1)
-		go func(i int) {
-			textures, _ := suite.Provider.GetForUsername("username")
-			results[i] = textures
-			wg.Done()
-		}(i)
-	}
-	wg.Wait()
-
-	suite.Assert().Equal(expectedResult, results[0])
-	suite.Assert().Equal(expectedResult, results[1])
-}
-
-func (suite *providerTestSuite) TestGetForNotAllowedMojangUsername() {
-	result, err := suite.Provider.GetForUsername("Not allowed")
-	suite.Assert().Error(err, "invalid username")
-	suite.Assert().Nil(result)
-}
-
-func (suite *providerTestSuite) TestGetErrorFromUuidsProvider() {
-	var expectedProfile *mojang.ProfileInfo
-	var expectedResult *mojang.SignedTexturesResponse
-	err := errors.New("mock error")
-
-	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", &ValueNotFound{}).Once()
-	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, err).Once()
-	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, err).Once()
-
-	suite.Storage.On("GetUuid", "username").Once().Return("", &ValueNotFound{})
-	suite.UuidsProvider.On("GetUuid", "username").Once().Return(nil, err)
-
-	result, resErr := suite.Provider.GetForUsername("username")
-	suite.Assert().Nil(result)
-	suite.Assert().Equal(err, resErr)
-}
-
-func (suite *providerTestSuite) TestGetErrorFromTexturesProvider() {
-	expectedProfile := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
-	var expectedResult *mojang.SignedTexturesResponse
-	err := errors.New("mock error")
-
-	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", &ValueNotFound{}).Once()
-	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
-	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
-	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, err).Once()
-	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, err).Once()
-
-	suite.Storage.On("GetUuid", "username").Return("", &ValueNotFound{})
-	suite.Storage.On("StoreUuid", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Return(nil)
-	suite.UuidsProvider.On("GetUuid", "username").Once().Return(expectedProfile, nil)
-	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil, err)
-
-	result, resErr := suite.Provider.GetForUsername("username")
-	suite.Assert().Nil(result)
-	suite.Assert().Equal(err, resErr)
-}
--- a/mojangtextures/nil_mojang_textures.go
+++ b/mojangtextures/nil_mojang_textures.go
@@ -1,12 +0,0 @@
-package mojangtextures
-
-import (
-	"github.com/elyby/chrly/api/mojang"
-)
-
-type NilProvider struct {
-}
-
-func (p *NilProvider) GetForUsername(username string) (*mojang.SignedTexturesResponse, error) {
-	return nil, nil
-}
--- a/mojangtextures/nil_mojang_textures_test.go
+++ b/mojangtextures/nil_mojang_textures_test.go
@@ -1,14 +0,0 @@
-package mojangtextures
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNilProvider_GetForUsername(t *testing.T) {
-	provider := &NilProvider{}
-	result, err := provider.GetForUsername("username")
-	assert.Nil(t, result)
-	assert.Nil(t, err)
-}
--- a/mojangtextures/remote_api_uuids_provider.go
+++ b/mojangtextures/remote_api_uuids_provider.go
@@ -1,67 +0,0 @@
-package mojangtextures
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"net/http"
-	. "net/url"
-	"path"
-
-	"github.com/elyby/chrly/api/mojang"
-	"github.com/elyby/chrly/version"
-)
-
-var HttpClient = &http.Client{
-	Transport: &http.Transport{
-		MaxIdleConnsPerHost: 1024,
-	},
-}
-
-type RemoteApiUuidsProvider struct {
-	Emitter
-	Url    URL
-}
-
-func (ctx *RemoteApiUuidsProvider) GetUuid(username string) (*mojang.ProfileInfo, error) {
-	url := ctx.Url
-	url.Path = path.Join(url.Path, username)
-	urlStr := url.String()
-
-	request, _ := http.NewRequest("GET", urlStr, nil)
-	request.Header.Add("Accept", "application/json")
-	// Change default User-Agent to allow specify "Username -> UUID at time" Mojang's api endpoint
-	request.Header.Add("User-Agent", "Chrly/"+version.Version())
-
-	ctx.Emit("mojang_textures:remote_api_uuids_provider:before_request", urlStr)
-	response, err := HttpClient.Do(request)
-	ctx.Emit("mojang_textures:remote_api_uuids_provider:after_request", response, err)
-	if err != nil {
-		return nil, err
-	}
-	defer response.Body.Close()
-
-	if response.StatusCode == 204 {
-		return nil, nil
-	}
-
-	if response.StatusCode != 200 {
-		return nil, &UnexpectedRemoteApiResponse{response}
-	}
-
-	var result *mojang.ProfileInfo
-	body, _ := ioutil.ReadAll(response.Body)
-	err = json.Unmarshal(body, &result)
-	if err != nil {
-		return nil, err
-	}
-
-	return result, nil
-}
-
-type UnexpectedRemoteApiResponse struct {
-	Response *http.Response
-}
-
-func (*UnexpectedRemoteApiResponse) Error() string {
-	return "Unexpected remote api response"
-}
--- a/mojangtextures/remote_api_uuids_provider_test.go
+++ b/mojangtextures/remote_api_uuids_provider_test.go
@@ -1,167 +0,0 @@
-package mojangtextures
-
-import (
-	"net"
-	"net/http"
-	. "net/url"
-	"testing"
-
-	"github.com/h2non/gock"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/suite"
-)
-
-type remoteApiUuidsProviderTestSuite struct {
-	suite.Suite
-
-	Provider *RemoteApiUuidsProvider
-	Emitter  *mockEmitter
-}
-
-func (suite *remoteApiUuidsProviderTestSuite) SetupSuite() {
-	client := &http.Client{}
-	gock.InterceptClient(client)
-
-	HttpClient = client
-}
-
-func (suite *remoteApiUuidsProviderTestSuite) SetupTest() {
-	suite.Emitter = &mockEmitter{}
-	suite.Provider = &RemoteApiUuidsProvider{
-		Emitter: suite.Emitter,
-	}
-}
-
-func (suite *remoteApiUuidsProviderTestSuite) TearDownTest() {
-	suite.Emitter.AssertExpectations(suite.T())
-	gock.Off()
-}
-
-func TestRemoteApiUuidsProvider(t *testing.T) {
-	suite.Run(t, new(remoteApiUuidsProviderTestSuite))
-}
-
-func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForValidUsername() {
-	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
-	suite.Emitter.On("Emit",
-		"mojang_textures:remote_api_uuids_provider:after_request",
-		mock.AnythingOfType("*http.Response"),
-		nil,
-	).Once()
-
-	gock.New("http://example.com").
-		Get("/subpath/username").
-		Reply(200).
-		JSON(map[string]interface{}{
-			"id":   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-			"name": "username",
-		})
-
-	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
-	result, err := suite.Provider.GetUuid("username")
-
-	assert := suite.Assert()
-	if assert.NoError(err) {
-		assert.Equal("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", result.Id)
-		assert.Equal("username", result.Name)
-		assert.False(result.IsLegacy)
-		assert.False(result.IsDemo)
-	}
-}
-
-func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForNotExistsUsername() {
-	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
-	suite.Emitter.On("Emit",
-		"mojang_textures:remote_api_uuids_provider:after_request",
-		mock.AnythingOfType("*http.Response"),
-		nil,
-	).Once()
-
-	gock.New("http://example.com").
-		Get("/subpath/username").
-		Reply(204)
-
-	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
-	result, err := suite.Provider.GetUuid("username")
-
-	assert := suite.Assert()
-	assert.Nil(result)
-	assert.Nil(err)
-}
-
-func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForNon20xResponse() {
-	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
-	suite.Emitter.On("Emit",
-		"mojang_textures:remote_api_uuids_provider:after_request",
-		mock.AnythingOfType("*http.Response"),
-		nil,
-	).Once()
-
-	gock.New("http://example.com").
-		Get("/subpath/username").
-		Reply(504).
-		BodyString("504 Gateway Timeout")
-
-	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
-	result, err := suite.Provider.GetUuid("username")
-
-	assert := suite.Assert()
-	assert.Nil(result)
-	assert.EqualError(err, "Unexpected remote api response")
-}
-
-func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForNotSuccessRequest() {
-	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
-	suite.Emitter.On("Emit",
-		"mojang_textures:remote_api_uuids_provider:after_request",
-		mock.AnythingOfType("*http.Response"),
-		mock.AnythingOfType("*url.Error"),
-	).Once()
-
-	expectedError := &net.OpError{Op: "dial"}
-
-	gock.New("http://example.com").
-		Get("/subpath/username").
-		ReplyError(expectedError)
-
-	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
-	result, err := suite.Provider.GetUuid("username")
-
-	assert := suite.Assert()
-	assert.Nil(result)
-	if assert.Error(err) {
-		assert.IsType(&Error{}, err)
-		casterErr, _ := err.(*Error)
-		assert.Equal(expectedError, casterErr.Err)
-	}
-}
-
-func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForInvalidSuccessResponse() {
-	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
-	suite.Emitter.On("Emit",
-		"mojang_textures:remote_api_uuids_provider:after_request",
-		mock.AnythingOfType("*http.Response"),
-		nil,
-	).Once()
-
-	gock.New("http://example.com").
-		Get("/subpath/username").
-		Reply(200).
-		BodyString("completely not json")
-
-	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
-	result, err := suite.Provider.GetUuid("username")
-
-	assert := suite.Assert()
-	assert.Nil(result)
-	assert.Error(err)
-}
-
-func shouldParseUrl(rawUrl string) URL {
-	url, err := Parse(rawUrl)
-	if err != nil {
-		panic(err)
-	}
-
-	return *url
-}
--- a/mojangtextures/storage.go
+++ b/mojangtextures/storage.go
@@ -1,61 +0,0 @@
-package mojangtextures
-
-import (
-	"github.com/elyby/chrly/api/mojang"
-)
-
-// UuidsStorage is a key-value storage of Mojang usernames pairs to its UUIDs,
-// used to reduce the load on the account information queue
-type UuidsStorage interface {
-	// Since only primitive types are used in this method, you should return a special error ValueNotFound
-	// to return the information that no error has occurred and username does not have uuid
-	GetUuid(username string) (string, error)
-	// An empty uuid value can be passed if the corresponding account has not been found
-	StoreUuid(username string, uuid string) error
-}
-
-// TexturesStorage is a Mojang's textures storage, used as a values cache to avoid 429 errors
-type TexturesStorage interface {
-	// Error should not have nil value only if the repository failed to determine if there are any textures
-	// for this uuid or not at all. If there is information about the absence of textures, nil nil should be returned
-	GetTextures(uuid string) (*mojang.SignedTexturesResponse, error)
-	// The nil value can be passed when there are no textures for the corresponding uuid and we know about it
-	StoreTextures(uuid string, textures *mojang.SignedTexturesResponse)
-}
-
-type Storage interface {
-	UuidsStorage
-	TexturesStorage
-}
-
-// SeparatedStorage allows you to use separate storage engines to satisfy
-// the Storage interface
-type SeparatedStorage struct {
-	UuidsStorage
-	TexturesStorage
-}
-
-func (s *SeparatedStorage) GetUuid(username string) (string, error) {
-	return s.UuidsStorage.GetUuid(username)
-}
-
-func (s *SeparatedStorage) StoreUuid(username string, uuid string) error {
-	return s.UuidsStorage.StoreUuid(username, uuid)
-}
-
-func (s *SeparatedStorage) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
-	return s.TexturesStorage.GetTextures(uuid)
-}
-
-func (s *SeparatedStorage) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
-	s.TexturesStorage.StoreTextures(uuid, textures)
-}
-
-// This error can be used to indicate, that requested
-// value doesn't exists in the storage
-type ValueNotFound struct {
-}
-
-func (*ValueNotFound) Error() string {
-	return "value not found in the storage"
-}
--- a/mojangtextures/storage_test.go
+++ b/mojangtextures/storage_test.go
@@ -1,89 +0,0 @@
-package mojangtextures
-
-import (
-	"github.com/elyby/chrly/api/mojang"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"testing"
-)
-
-type uuidsStorageMock struct {
-	mock.Mock
-}
-
-func (m *uuidsStorageMock) GetUuid(username string) (string, error) {
-	args := m.Called(username)
-	return args.String(0), args.Error(1)
-}
-
-func (m *uuidsStorageMock) StoreUuid(username string, uuid string) error {
-	m.Called(username, uuid)
-	return nil
-}
-
-type texturesStorageMock struct {
-	mock.Mock
-}
-
-func (m *texturesStorageMock) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
-	args := m.Called(uuid)
-	var result *mojang.SignedTexturesResponse
-	if casted, ok := args.Get(0).(*mojang.SignedTexturesResponse); ok {
-		result = casted
-	}
-
-	return result, args.Error(1)
-}
-
-func (m *texturesStorageMock) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
-	m.Called(uuid, textures)
-}
-
-func TestSplittedStorage(t *testing.T) {
-	createMockedStorage := func() (*SeparatedStorage, *uuidsStorageMock, *texturesStorageMock) {
-		uuidsStorage := &uuidsStorageMock{}
-		texturesStorage := &texturesStorageMock{}
-
-		return &SeparatedStorage{uuidsStorage, texturesStorage}, uuidsStorage, texturesStorage
-	}
-
-	t.Run("GetUuid", func(t *testing.T) {
-		storage, uuidsMock, _ := createMockedStorage()
-		uuidsMock.On("GetUuid", "username").Once().Return("find me", nil)
-		result, err := storage.GetUuid("username")
-		assert.Nil(t, err)
-		assert.Equal(t, "find me", result)
-		uuidsMock.AssertExpectations(t)
-	})
-
-	t.Run("StoreUuid", func(t *testing.T) {
-		storage, uuidsMock, _ := createMockedStorage()
-		uuidsMock.On("StoreUuid", "username", "result").Once()
-		_ = storage.StoreUuid("username", "result")
-		uuidsMock.AssertExpectations(t)
-	})
-
-	t.Run("GetTextures", func(t *testing.T) {
-		result := &mojang.SignedTexturesResponse{Id: "mock id"}
-		storage, _, texturesMock := createMockedStorage()
-		texturesMock.On("GetTextures", "uuid").Once().Return(result, nil)
-		returned, err := storage.GetTextures("uuid")
-		assert.Nil(t, err)
-		assert.Equal(t, result, returned)
-		texturesMock.AssertExpectations(t)
-	})
-
-	t.Run("StoreTextures", func(t *testing.T) {
-		toStore := &mojang.SignedTexturesResponse{}
-		storage, _, texturesMock := createMockedStorage()
-		texturesMock.On("StoreTextures", "mock id", toStore).Once()
-		storage.StoreTextures("mock id", toStore)
-		texturesMock.AssertExpectations(t)
-	})
-}
-
-func TestValueNotFound_Error(t *testing.T) {
-	err := &ValueNotFound{}
-	assert.Equal(t, "value not found in the storage", err.Error())
-}
--- a/script/coverage
+++ b/script/coverage
@@ -0,0 +1,46 @@
+#!/bin/sh
+# Based on https://github.com/mlafeldt/chef-runner/blob/34269dbb726c243dff9764007e7bd7f0fe9ee331/script/coverage
+# Generate test coverage statistics for Go packages.
+#
+# Works around the fact that `go test -coverprofile` currently does not work
+# with multiple packages, see https://code.google.com/p/go/issues/detail?id=6909
+#
+# Usage: script/coverage [--html]
+#
+#     --html      Additionally create HTML report and open it in browser
+#
+
+set -e
+
+workdir=.cover
+profile="$workdir/cover.out"
+mode=count
+
+generate_cover_data() {
+    rm -rf "$workdir"
+    mkdir "$workdir"
+
+    go test -i "$@" # compile dependencies first before serializing go test invocations
+    for pkg in "$@"; do
+        f="$workdir/$(echo $pkg | tr / -).cover"
+        go test -covermode="$mode" -coverprofile="$f" "$pkg"
+    done
+
+    echo "mode: $mode" >"$profile"
+    grep -h -v "^mode:" "$workdir"/*.cover >>"$profile"
+}
+
+show_cover_report() {
+    go tool cover -${1}="$profile"
+}
+
+generate_cover_data $(go list ./... | grep -v /vendor/)
+show_cover_report func
+case "$1" in
+"")
+    ;;
+--html)
+    show_cover_report html ;;
+*)
+    echo >&2 "error: invalid option: $1"; exit 1 ;;
+esac
--- a/script/mocks
+++ b/script/mocks
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+mockgen -source=interfaces/repositories.go -destination=interfaces/mock_interfaces/mock_interfaces.go
+mockgen -source=interfaces/auth.go -destination=interfaces/mock_interfaces/mock_auth.go
--- a/script/test
+++ b/script/test
@@ -0,0 +1,27 @@
+#!/bin/sh
+# Based on https://github.com/mlafeldt/chef-runner/blob/34269dbb726c243dff9764007e7bd7f0fe9ee331/script/test
+# Run package tests for a file/directory, or all tests if no argument is passed.
+# Useful to e.g. execute package tests for the file currently open in Vim.
+# Usage: script/test [path]
+
+set -e
+
+go_pkg_from_path() {
+    path=$1
+    if test -d "$path"; then
+        dir="$path"
+    else
+        dir=$(dirname "$path")
+    fi
+    (cd "$dir" && go list)
+}
+
+if test $# -gt 0; then
+    pkg=$(go_pkg_from_path "$1")
+    verbose=-v
+else
+    pkg=$(go list ./... | grep -v /vendor/)
+    verbose=
+fi
+
+exec go test ${GOTESTOPTS:-$verbose} $pkg
--- a/version/version.go
+++ b/version/version.go
@@ -1,14 +0,0 @@
-package version
-
-var (
-	version = ""
-	commit  = ""
-)
-
-func Version() string {
-	return version
-}
-
-func Commit() string {
-	return commit
-}
Author	SHA1	Message	Date
ErickSkrauch	7734f2cbd5	Merge branch 'master' into ely	2018-02-17 01:52:47 +03:00
ErickSkrauch	55b8c12955	Restore Ely documentation link on the 404 page	2018-02-16 21:01:01 +03:00
ErickSkrauch	10ff6f34fb	Restore Ely signed textures ely property	2018-02-16 21:01:01 +03:00
ErickSkrauch	31cd75ffa7	Restore Ely faces API	2018-02-16 21:01:01 +03:00