From c086f6e0882fea7b54e4116fa6c4d07cd3b4cf94 Mon Sep 17 00:00:00 2001
From: Mathieu Degand <32012475+Galimede@users.noreply.github.com>
Date: Tue, 5 Jan 2021 12:51:45 +0100
Subject: [PATCH] Initial commit

---
 .gitignore                           |  57 ++++
 LICENSE                              |   7 +
 Pipfile                              |  33 ++
 Pipfile.lock                         | 467 +++++++++++++++++++++++++++
 Procfile                             |   1 +
 Readme.md                            |  64 ++++
 Vagrantfile                          | 103 ++++++
 autoapp.py                           |  10 +
 conduit/__init__.py                  |   1 +
 conduit/app.py                       |  80 +++++
 conduit/articles/__init__.py         |   3 +
 conduit/articles/models.py           | 112 +++++++
 conduit/articles/serializers.py      |  88 +++++
 conduit/articles/views.py            | 168 ++++++++++
 conduit/commands.py                  | 123 +++++++
 conduit/compat.py                    |  18 ++
 conduit/database.py                  |  44 +++
 conduit/exceptions.py                |  47 +++
 conduit/extensions.py                |  50 +++
 conduit/profile/__init__.py          |   1 +
 conduit/profile/models.py            |  65 ++++
 conduit/profile/serializers.py       |  27 ++
 conduit/profile/views.py             |  45 +++
 conduit/settings.py                  |  60 ++++
 conduit/user/__init__.py             |   3 +
 conduit/user/models.py               |  39 +++
 conduit/user/serializers.py          |  38 +++
 conduit/user/views.py                |  66 ++++
 conduit/utils.py                     |  11 +
 image.png                            | Bin 0 -> 49006 bytes
 migrations/README                    |   1 +
 migrations/alembic.ini               |  45 +++
 migrations/env.py                    |  96 ++++++
 migrations/script.py.mako            |  24 ++
 migrations/versions/2267f00a4594_.py | 101 ++++++
 requirements.txt                     |   3 +
 requirements/dev.txt                 |   9 +
 requirements/prod.txt                |  18 ++
 setup.cfg                            |   2 +
 tests/__init__.py                    |   1 +
 tests/conftest.py                    |  61 ++++
 tests/factories.py                   |  30 ++
 tests/test_articles.py               | 136 ++++++++
 tests/test_authentication.py         |  65 ++++
 tests/test_config.py                 |  18 ++
 tests/test_models.py                 | 181 +++++++++++
 tests/test_profile.py                |  45 +++
 47 files changed, 2667 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 LICENSE
 create mode 100644 Pipfile
 create mode 100644 Pipfile.lock
 create mode 100644 Procfile
 create mode 100644 Readme.md
 create mode 100644 Vagrantfile
 create mode 100755 autoapp.py
 create mode 100644 conduit/__init__.py
 create mode 100644 conduit/app.py
 create mode 100644 conduit/articles/__init__.py
 create mode 100644 conduit/articles/models.py
 create mode 100644 conduit/articles/serializers.py
 create mode 100644 conduit/articles/views.py
 create mode 100644 conduit/commands.py
 create mode 100644 conduit/compat.py
 create mode 100644 conduit/database.py
 create mode 100644 conduit/exceptions.py
 create mode 100644 conduit/extensions.py
 create mode 100644 conduit/profile/__init__.py
 create mode 100644 conduit/profile/models.py
 create mode 100644 conduit/profile/serializers.py
 create mode 100644 conduit/profile/views.py
 create mode 100644 conduit/settings.py
 create mode 100644 conduit/user/__init__.py
 create mode 100644 conduit/user/models.py
 create mode 100644 conduit/user/serializers.py
 create mode 100644 conduit/user/views.py
 create mode 100644 conduit/utils.py
 create mode 100644 image.png
 create mode 100644 migrations/README
 create mode 100644 migrations/alembic.ini
 create mode 100644 migrations/env.py
 create mode 100644 migrations/script.py.mako
 create mode 100644 migrations/versions/2267f00a4594_.py
 create mode 100644 requirements.txt
 create mode 100644 requirements/dev.txt
 create mode 100644 requirements/prod.txt
 create mode 100644 setup.cfg
 create mode 100644 tests/__init__.py
 create mode 100644 tests/conftest.py
 create mode 100644 tests/factories.py
 create mode 100644 tests/test_articles.py
 create mode 100644 tests/test_authentication.py
 create mode 100644 tests/test_config.py
 create mode 100644 tests/test_models.py
 create mode 100644 tests/test_profile.py

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6592afb
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,57 @@
+*.py[cod]
+
+# C extensions
+*.so
+
+# Packages
+*.egg
+*.egg-info
+build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+lib
+lib64
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+nosetests.xml
+
+# Translations
+*.mo
+
+# Mr Developer
+.mr.developer.cfg
+.project
+.pydevproject
+
+# Complexity
+output/*.html
+output/*/index.html
+
+# Sphinx
+docs/_build
+
+.webassets-cache
+
+# Virtualenvs
+env/
+dev.db
+.cache/v/cache
+
+# Intellij IDEA based IDEs folder
+.idea/**
+
+# Pytest cache
+.pytest_cache/**
+
+# Vagrant machines
+.vagrant/**
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..0cc8a7a
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,7 @@
+Copyright 2017 Mohamed Aziz Knani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Pipfile b/Pipfile
new file mode 100644
index 0000000..34233f7
--- /dev/null
+++ b/Pipfile
@@ -0,0 +1,33 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+werkzeug = "*"
+sqlalchemy = "*"
+click = "*"
+marshmallow = "*"
+flask-apispec = "*"
+unicode-slugify = "*"
+"psycopg2" = "*"
+gunicorn = "*"
+Flask-Caching = "*"
+Flask-SQLAlchemy = "*"
+Flask-Bcrypt = "*"
+Flask = "*"
+PyJWT = "*"
+Flask-JWT-Extended = "*"
+Flask-Migrate = "*"
+Flask-Cors = "*"
+
+[dev-packages]
+# Testing
+pytest = "*"
+WebTest = "*"
+factory-boy = "*"
+# For python 3
+Faker = "*"
+
+[requires]
+python_version = "3.7"
diff --git a/Pipfile.lock b/Pipfile.lock
new file mode 100644
index 0000000..1350c96
--- /dev/null
+++ b/Pipfile.lock
@@ -0,0 +1,467 @@
+{
+    "_meta": {
+        "hash": {
+            "sha256": "d718acf10c644a164aa41698100acbfd104741e6c6988e45eb5b40037c4c1798"
+        },
+        "pipfile-spec": 6,
+        "requires": {
+            "python_version": "3.7"
+        },
+        "sources": [
+            {
+                "name": "pypi",
+                "url": "https://pypi.org/simple",
+                "verify_ssl": true
+            }
+        ]
+    },
+    "default": {
+        "alembic": {
+            "hashes": [
+                "sha256:52d73b1d750f1414fa90c25a08da47b87de1e4ad883935718a8f36396e19e78e",
+                "sha256:eb7db9b4510562ec37c91d00b00d95fde076c1030d3f661aea882eec532b3565"
+            ],
+            "version": "==1.0.0"
+        },
+        "apispec": {
+            "hashes": [
+                "sha256:1661bc574b1579ef72883aafd87c0178d1c129659cd4f1c76a68fcc852e1b4ed",
+                "sha256:3ad66b1aa0a330db71ab424ca17b946d80ef5923d28da5ccdad692a7937efb9e"
+            ],
+            "version": "==0.39.0"
+        },
+        "bcrypt": {
+            "hashes": [
+                "sha256:01477981abf74e306e8ee31629a940a5e9138de000c6b0898f7f850461c4a0a5",
+                "sha256:054d6e0acaea429e6da3613fcd12d05ee29a531794d96f6ab959f29a39f33391",
+                "sha256:0872eeecdf9a429c1420158500eedb323a132bc5bf3339475151c52414729e70",
+                "sha256:09a3b8c258b815eadb611bad04ca15ec77d86aa9ce56070e1af0d5932f17642a",
+                "sha256:0f317e4ffbdd15c3c0f8ab5fbd86aa9aabc7bea18b5cc5951b456fe39e9f738c",
+                "sha256:2788c32673a2ad0062bea850ab73cffc0dba874db10d7a3682b6f2f280553f20",
+                "sha256:321d4d48be25b8d77594d8324c0585c80ae91ac214f62db9098734e5e7fb280f",
+                "sha256:346d6f84ff0b493dbc90c6b77136df83e81f903f0b95525ee80e5e6d5e4eef84",
+                "sha256:34dd60b90b0f6de94a89e71fcd19913a30e83091c8468d0923a93a0cccbfbbff",
+                "sha256:3b4c23300c4eded8895442c003ae9b14328ae69309ac5867e7530de8bdd7875d",
+                "sha256:43d1960e7db14042319c46925892d5fa99b08ff21d57482e6f5328a1aca03588",
+                "sha256:49e96267cd9be55a349fd74f9852eb9ae2c427cd7f6455d0f1765d7332292832",
+                "sha256:63e06ffdaf4054a89757a3a1ab07f1b922daf911743114a54f7c561b9e1baa58",
+                "sha256:67ed1a374c9155ec0840214ce804616de49c3df9c5bc66740687c1c9b1cd9e8d",
+                "sha256:6b662a5669186439f4f583636c8d6ea77cf92f7cfe6aae8d22edf16c36840574",
+                "sha256:6efd9ca20aefbaf2e7e6817a2c6ed4a50ff6900fafdea1bcb1d0e9471743b144",
+                "sha256:8569844a5d8e1fdde4d7712a05ab2e6061343ac34af6e7e3d7935b2bd1907bfd",
+                "sha256:8629ea6a8a59f865add1d6a87464c3c676e60101b8d16ef404d0a031424a8491",
+                "sha256:988cac675e25133d01a78f2286189c1f01974470817a33eaf4cfee573cfb72a5",
+                "sha256:9a6fedda73aba1568962f7543a1f586051c54febbc74e87769bad6a4b8587c39",
+                "sha256:9eced8962ce3b7124fe20fd358cf8c7470706437fa064b9874f849ad4c5866fc",
+                "sha256:a005ed6163490988711ff732386b08effcbf8df62ae93dd1e5bda0714fad8afb",
+                "sha256:ae35dbcb6b011af6c840893b32399252d81ff57d52c13e12422e16b5fea1d0fb",
+                "sha256:b1e8491c6740f21b37cca77bc64677696a3fb9f32360794d57fa8477b7329eda",
+                "sha256:c906bdb482162e9ef48eea9f8c0d967acceb5c84f2d25574c7d2a58d04861df1",
+                "sha256:cb18ffdc861dbb244f14be32c47ab69604d0aca415bee53485fcea4f8e93d5ef",
+                "sha256:cc2f24dc1c6c88c56248e93f28d439ee4018338567b0bbb490ea26a381a29b1e",
+                "sha256:d860c7fff18d49e20339fc6dffc2d485635e36d4b2cccf58f45db815b64100b4",
+                "sha256:d86da365dda59010ba0d1ac45aa78390f56bf7f992e65f70b3b081d5e5257b09",
+                "sha256:e22f0997622e1ceec834fd25947dc2ee2962c2133ea693d61805bc867abaf7ea",
+                "sha256:f2fe545d27a619a552396533cddf70d83cecd880a611cdfdbb87ca6aec52f66b",
+                "sha256:f425e925485b3be48051f913dbe17e08e8c48588fdf44a26b8b14067041c0da6",
+                "sha256:f7fd3ed3745fe6e81e28dc3b3d76cce31525a91f32a387e1febd6b982caf8cdb",
+                "sha256:f9210820ee4818d84658ed7df16a7f30c9fba7d8b139959950acef91745cc0f7"
+            ],
+            "version": "==3.1.4"
+        },
+        "cffi": {
+            "hashes": [
+                "sha256:151b7eefd035c56b2b2e1eb9963c90c6302dc15fbd8c1c0a83a163ff2c7d7743",
+                "sha256:1553d1e99f035ace1c0544050622b7bc963374a00c467edafac50ad7bd276aef",
+                "sha256:1b0493c091a1898f1136e3f4f991a784437fac3673780ff9de3bcf46c80b6b50",
+                "sha256:2ba8a45822b7aee805ab49abfe7eec16b90587f7f26df20c71dd89e45a97076f",
+                "sha256:3bb6bd7266598f318063e584378b8e27c67de998a43362e8fce664c54ee52d30",
+                "sha256:3c85641778460581c42924384f5e68076d724ceac0f267d66c757f7535069c93",
+                "sha256:3eb6434197633b7748cea30bf0ba9f66727cdce45117a712b29a443943733257",
+                "sha256:495c5c2d43bf6cebe0178eb3e88f9c4aa48d8934aa6e3cddb865c058da76756b",
+                "sha256:4c91af6e967c2015729d3e69c2e51d92f9898c330d6a851bf8f121236f3defd3",
+                "sha256:57b2533356cb2d8fac1555815929f7f5f14d68ac77b085d2326b571310f34f6e",
+                "sha256:770f3782b31f50b68627e22f91cb182c48c47c02eb405fd689472aa7b7aa16dc",
+                "sha256:79f9b6f7c46ae1f8ded75f68cf8ad50e5729ed4d590c74840471fc2823457d04",
+                "sha256:7a33145e04d44ce95bcd71e522b478d282ad0eafaf34fe1ec5bbd73e662f22b6",
+                "sha256:857959354ae3a6fa3da6651b966d13b0a8bed6bbc87a0de7b38a549db1d2a359",
+                "sha256:87f37fe5130574ff76c17cab61e7d2538a16f843bb7bca8ebbc4b12de3078596",
+                "sha256:95d5251e4b5ca00061f9d9f3d6fe537247e145a8524ae9fd30a2f8fbce993b5b",
+                "sha256:9d1d3e63a4afdc29bd76ce6aa9d58c771cd1599fbba8cf5057e7860b203710dd",
+                "sha256:a36c5c154f9d42ec176e6e620cb0dd275744aa1d804786a71ac37dc3661a5e95",
+                "sha256:a6a5cb8809091ec9ac03edde9304b3ad82ad4466333432b16d78ef40e0cce0d5",
+                "sha256:ae5e35a2c189d397b91034642cb0eab0e346f776ec2eb44a49a459e6615d6e2e",
+                "sha256:b0f7d4a3df8f06cf49f9f121bead236e328074de6449866515cea4907bbc63d6",
+                "sha256:b75110fb114fa366b29a027d0c9be3709579602ae111ff61674d28c93606acca",
+                "sha256:ba5e697569f84b13640c9e193170e89c13c6244c24400fc57e88724ef610cd31",
+                "sha256:be2a9b390f77fd7676d80bc3cdc4f8edb940d8c198ed2d8c0be1319018c778e1",
+                "sha256:ca1bd81f40adc59011f58159e4aa6445fc585a32bb8ac9badf7a2c1aa23822f2",
+                "sha256:d5d8555d9bfc3f02385c1c37e9f998e2011f0db4f90e250e5bc0c0a85a813085",
+                "sha256:e55e22ac0a30023426564b1059b035973ec82186ddddbac867078435801c7801",
+                "sha256:e90f17980e6ab0f3c2f3730e56d1fe9bcba1891eeea58966e89d352492cc74f4",
+                "sha256:ecbb7b01409e9b782df5ded849c178a0aa7c906cf8c5a67368047daab282b184",
+                "sha256:ed01918d545a38998bfa5902c7c00e0fee90e957ce036a4000a88e3fe2264917",
+                "sha256:edabd457cd23a02965166026fd9bfd196f4324fe6032e866d0f3bd0301cd486f",
+                "sha256:fdf1c1dc5bafc32bc5d08b054f94d659422b05aba244d6be4ddc1c72d9aa70fb"
+            ],
+            "version": "==1.11.5"
+        },
+        "click": {
+            "hashes": [
+                "sha256:29f99fc6125fbc931b758dc053b3114e55c77a6e4c6c3a2674a2dc986016381d",
+                "sha256:f15516df478d5a56180fbf80e68f206010e6d160fc39fa508b65e035fd75130b"
+            ],
+            "index": "pypi",
+            "version": "==6.7"
+        },
+        "flask": {
+            "hashes": [
+                "sha256:2271c0070dbcb5275fad4a82e29f23ab92682dc45f9dfbc22c02ba9b9322ce48",
+                "sha256:a080b744b7e345ccfcbc77954861cb05b3c63786e93f2b3875e0913d44b43f05"
+            ],
+            "index": "pypi",
+            "version": "==1.0.2"
+        },
+        "flask-apispec": {
+            "hashes": [
+                "sha256:1a3f83788b67b6e05c1bb7ffff9cd455fb5bd3800caac8b7bc4ce462b7c5a94b",
+                "sha256:aae3656220e4cbf447d61345cb61a495746e4dede7f6d83faab1f8665638a801"
+            ],
+            "index": "pypi",
+            "version": "==0.7.0"
+        },
+        "flask-bcrypt": {
+            "hashes": [
+                "sha256:d71c8585b2ee1c62024392ebdbc447438564e2c8c02b4e57b56a4cafd8d13c5f"
+            ],
+            "index": "pypi",
+            "version": "==0.7.1"
+        },
+        "flask-caching": {
+            "hashes": [
+                "sha256:44fe827c6cc519d48fb0945fa05ae3d128af9a98f2a6e71d4702fd512534f227",
+                "sha256:e34f24631ba240e09fe6241e1bf652863e0cff06a1a94598e23be526bc2e4985"
+            ],
+            "index": "pypi",
+            "version": "==1.4.0"
+        },
+        "flask-cors": {
+            "hashes": [
+                "sha256:e4c8fc15d3e4b4cce6d3b325f2bab91e0e09811a61f50d7a53493bc44242a4f1",
+                "sha256:ecc016c5b32fa5da813ec8d272941cfddf5f6bba9060c405a70285415cbf24c9"
+            ],
+            "index": "pypi",
+            "version": "==3.0.6"
+        },
+        "flask-jwt-extended": {
+            "hashes": [
+                "sha256:3f28e6fe9bba450ccf48f640b7a7c7b61c9f520dfb9a80854867b5203bd3cb49"
+            ],
+            "index": "pypi",
+            "version": "==3.10.0"
+        },
+        "flask-migrate": {
+            "hashes": [
+                "sha256:83ebc105f87357ddd3968f83510d2b1092f006660b1c6ba07a4efce036ca567d",
+                "sha256:cd1b4e6cb829eeb41c02ad9202d83bef5f4b7a036dd9fad72ce96ad1e22efb07"
+            ],
+            "index": "pypi",
+            "version": "==2.2.1"
+        },
+        "flask-sqlalchemy": {
+            "hashes": [
+                "sha256:3bc0fac969dd8c0ace01b32060f0c729565293302f0c4269beed154b46bec50b",
+                "sha256:5971b9852b5888655f11db634e87725a9031e170f37c0ce7851cf83497f56e53"
+            ],
+            "index": "pypi",
+            "version": "==2.3.2"
+        },
+        "gunicorn": {
+            "hashes": [
+                "sha256:aa8e0b40b4157b36a5df5e599f45c9c76d6af43845ba3b3b0efe2c70473c2471",
+                "sha256:fa2662097c66f920f53f70621c6c58ca4a3c4d3434205e608e121b5b3b71f4f3"
+            ],
+            "index": "pypi",
+            "version": "==19.9.0"
+        },
+        "itsdangerous": {
+            "hashes": [
+                "sha256:cbb3fcf8d3e33df861709ecaf89d9e6629cff0a217bc2848f1b41cd30d360519"
+            ],
+            "version": "==0.24"
+        },
+        "jinja2": {
+            "hashes": [
+                "sha256:74c935a1b8bb9a3947c50a54766a969d4846290e1e788ea44c1392163723c3bd",
+                "sha256:f84be1bb0040caca4cea721fcbbbbd61f9be9464ca236387158b0feea01914a4"
+            ],
+            "version": "==2.10"
+        },
+        "jsonify": {
+            "hashes": [
+                "sha256:f340032753577575e9777835809b283fdc9b251867d5d5600389131647f8bfe1"
+            ],
+            "index": "pypi",
+            "version": "==0.5"
+        },
+        "mako": {
+            "hashes": [
+                "sha256:4e02fde57bd4abb5ec400181e4c314f56ac3e49ba4fb8b0d50bba18cb27d25ae"
+            ],
+            "version": "==1.0.7"
+        },
+        "markupsafe": {
+            "hashes": [
+                "sha256:a6be69091dac236ea9c6bc7d012beab42010fa914c459791d627dad4910eb665"
+            ],
+            "version": "==1.0"
+        },
+        "marshmallow": {
+            "hashes": [
+                "sha256:171f409d48b44786b7df2793cbd7f1a9062f0fe2c14d547da536b5010f671ade",
+                "sha256:c231784b5a5d2b26e50c90f3038004a3552ec27658cde6e0a5a7279d0c5a8e26"
+            ],
+            "index": "pypi",
+            "version": "==2.15.3"
+        },
+        "psycopg2": {
+            "hashes": [
+                "sha256:0b9e48a1c1505699a64ac58815ca99104aacace8321e455072cee4f7fe7b2698",
+                "sha256:0f4c784e1b5a320efb434c66a50b8dd7e30a7dc047e8f45c0a8d2694bfe72781",
+                "sha256:0fdbaa32c9eb09ef09d425dc154628fca6fa69d2f7c1a33f889abb7e0efb3909",
+                "sha256:11fbf688d5c953c0a5ba625cc42dea9aeb2321942c7c5ed9341a68f865dc8cb1",
+                "sha256:19eaac4eb25ab078bd0f28304a0cb08702d120caadfe76bb1e6846ed1f68635e",
+                "sha256:3232ec1a3bf4dba97fbf9b03ce12e4b6c1d01ea3c85773903a67ced725728232",
+                "sha256:36f8f9c216fcca048006f6dd60e4d3e6f406afde26cfb99e063f137070139eaf",
+                "sha256:59c1a0e4f9abe970062ed35d0720935197800a7ef7a62b3a9e3a70588d9ca40b",
+                "sha256:6506c5ff88750948c28d41852c09c5d2a49f51f28c6d90cbf1b6808e18c64e88",
+                "sha256:6bc3e68ee16f571681b8c0b6d5c0a77bef3c589012352b3f0cf5520e674e9d01",
+                "sha256:6dbbd7aabbc861eec6b910522534894d9dbb507d5819bc982032c3ea2e974f51",
+                "sha256:6e737915de826650d1a5f7ff4ac6cf888a26f021a647390ca7bafdba0e85462b",
+                "sha256:6ed9b2cfe85abc720e8943c1808eeffd41daa73e18b7c1e1a228b0b91f768ccc",
+                "sha256:711ec617ba453fdfc66616db2520db3a6d9a891e3bf62ef9aba4c95bb4e61230",
+                "sha256:844dacdf7530c5c612718cf12bc001f59b2d9329d35b495f1ff25045161aa6af",
+                "sha256:86b52e146da13c896e50c5a3341a9448151f1092b1a4153e425d1e8b62fec508",
+                "sha256:985c06c2a0f227131733ae58d6a541a5bc8b665e7305494782bebdb74202b793",
+                "sha256:a86dfe45f4f9c55b1a2312ff20a59b30da8d39c0e8821d00018372a2a177098f",
+                "sha256:aa3cd07f7f7e3183b63d48300666f920828a9dbd7d7ec53d450df2c4953687a9",
+                "sha256:b1964ed645ef8317806d615d9ff006c0dadc09dfc54b99ae67f9ba7a1ec9d5d2",
+                "sha256:b2abbff9e4141484bb89b96eb8eae186d77bc6d5ffbec6b01783ee5c3c467351",
+                "sha256:cc33c3a90492e21713260095f02b12bee02b8d1f2c03a221d763ce04fa90e2e9",
+                "sha256:d7de3bf0986d777807611c36e809b77a13bf1888f5c8db0ebf24b47a52d10726",
+                "sha256:db5e3c52576cc5b93a959a03ccc3b02cb8f0af1fbbdc80645f7a215f0b864f3a",
+                "sha256:e168aa795ffbb11379c942cf95bf813c7db9aa55538eb61de8c6815e092416f5",
+                "sha256:e9ca911f8e2d3117e5241d5fa9aaa991cb22fb0792627eeada47425d706b5ec8",
+                "sha256:eccf962d41ca46e6326b97c8fe0a6687b58dfc1a5f6540ed071ff1474cea749e",
+                "sha256:efa19deae6b9e504a74347fe5e25c2cb9343766c489c2ae921b05f37338b18d1",
+                "sha256:f4b0460a21f784abe17b496f66e74157a6c36116fa86da8bf6aa028b9e8ad5fe",
+                "sha256:f93d508ca64d924d478fb11e272e09524698f0c581d9032e68958cfbdd41faef"
+            ],
+            "index": "pypi",
+            "version": "==2.7.5"
+        },
+        "pycparser": {
+            "hashes": [
+                "sha256:99a8ca03e29851d96616ad0404b4aad7d9ee16f25c9f9708a11faf2810f7b226"
+            ],
+            "version": "==2.18"
+        },
+        "pyjwt": {
+            "hashes": [
+                "sha256:30b1380ff43b55441283cc2b2676b755cca45693ae3097325dea01f3d110628c",
+                "sha256:4ee413b357d53fd3fb44704577afac88e72e878716116270d722723d65b42176"
+            ],
+            "index": "pypi",
+            "version": "==1.6.4"
+        },
+        "python-dateutil": {
+            "hashes": [
+                "sha256:1adb80e7a782c12e52ef9a8182bebeb73f1d7e24e374397af06fb4956c8dc5c0",
+                "sha256:e27001de32f627c22380a688bcc43ce83504a7bc5da472209b4c70f02829f0b8"
+            ],
+            "version": "==2.7.3"
+        },
+        "python-editor": {
+            "hashes": [
+                "sha256:a3c066acee22a1c94f63938341d4fb374e3fdd69366ed6603d7b24bed1efc565"
+            ],
+            "version": "==1.0.3"
+        },
+        "pyyaml": {
+            "hashes": [
+                "sha256:3d7da3009c0f3e783b2c873687652d83b1bbfd5c88e9813fb7e5b03c0dd3108b",
+                "sha256:3ef3092145e9b70e3ddd2c7ad59bdd0252a94dfe3949721633e41344de00a6bf",
+                "sha256:40c71b8e076d0550b2e6380bada1f1cd1017b882f7e16f09a65be98e017f211a",
+                "sha256:558dd60b890ba8fd982e05941927a3911dc409a63dcb8b634feaa0cda69330d3",
+                "sha256:a7c28b45d9f99102fa092bb213aa12e0aaf9a6a1f5e395d36166639c1f96c3a1",
+                "sha256:aa7dd4a6a427aed7df6fb7f08a580d68d9b118d90310374716ae90b710280af1",
+                "sha256:bc558586e6045763782014934bfaf39d48b8ae85a2713117d16c39864085c613",
+                "sha256:d46d7982b62e0729ad0175a9bc7e10a566fc07b224d2c79fafb5e032727eaa04",
+                "sha256:d5eef459e30b09f5a098b9cea68bebfeb268697f78d647bd255a085371ac7f3f",
+                "sha256:e01d3203230e1786cd91ccfdc8f8454c8069c91bee3962ad93b87a4b2860f537",
+                "sha256:e170a9e6fcfd19021dd29845af83bb79236068bf5fd4df3327c1be18182b2531"
+            ],
+            "version": "==3.13"
+        },
+        "six": {
+            "hashes": [
+                "sha256:70e8a77beed4562e7f14fe23a786b54f6296e34344c23bc42f07b15018ff98e9",
+                "sha256:832dc0e10feb1aa2c68dcc57dbb658f1c7e65b9b61af69048abc87a2db00a0eb"
+            ],
+            "version": "==1.11.0"
+        },
+        "sqlalchemy": {
+            "hashes": [
+                "sha256:e21e5561a85dcdf16b8520ae4daec7401c5c24558e0ce004f9b60be75c4b6957"
+            ],
+            "index": "pypi",
+            "version": "==1.2.9"
+        },
+        "unicode-slugify": {
+            "hashes": [
+                "sha256:34cf3afefa6480efe705a4fc0eaeeaf7f49754aec322ba3e8b2f27dc1cbcf650"
+            ],
+            "index": "pypi",
+            "version": "==0.1.3"
+        },
+        "unidecode": {
+            "hashes": [
+                "sha256:72f49d3729f3d8f5799f710b97c1451c5163102e76d64d20e170aedbbd923582",
+                "sha256:8c33dd588e0c9bc22a76eaa0c715a5434851f726131bd44a6c26471746efabf5"
+            ],
+            "version": "==1.0.22"
+        },
+        "webargs": {
+            "hashes": [
+                "sha256:7f76cea1989391480198840ef9cabb8041db7129e0a58f15e6962b92d4938a17",
+                "sha256:a4701fd0af6cc398005584865cd43a914e319d7a29942f757cd9dbc53e2a39ec"
+            ],
+            "version": "==3.0.2"
+        },
+        "werkzeug": {
+            "hashes": [
+                "sha256:c3fd7a7d41976d9f44db327260e263132466836cef6f91512889ed60ad26557c",
+                "sha256:d5da73735293558eb1651ee2fddc4d0dedcfa06538b8813a2e20011583c9e49b"
+            ],
+            "index": "pypi",
+            "version": "==0.14.1"
+        }
+    },
+    "develop": {
+        "atomicwrites": {
+            "hashes": [
+                "sha256:240831ea22da9ab882b551b31d4225591e5e447a68c5e188db5b89ca1d487585",
+                "sha256:a24da68318b08ac9c9c45029f4a10371ab5b20e4226738e150e6e7c571630ae6"
+            ],
+            "version": "==1.1.5"
+        },
+        "attrs": {
+            "hashes": [
+                "sha256:4b90b09eeeb9b88c35bc642cbac057e45a5fd85367b985bd2809c62b7b939265",
+                "sha256:e0d0eb91441a3b53dab4d9b743eafc1ac44476296a2053b6ca3af0b139faf87b"
+            ],
+            "version": "==18.1.0"
+        },
+        "beautifulsoup4": {
+            "hashes": [
+                "sha256:11a9a27b7d3bddc6d86f59fb76afb70e921a25ac2d6cc55b40d072bd68435a76",
+                "sha256:7015e76bf32f1f574636c4288399a6de66ce08fb7b2457f628a8d70c0fbabb11",
+                "sha256:808b6ac932dccb0a4126558f7dfdcf41710dd44a4ef497a0bb59a77f9f078e89"
+            ],
+            "version": "==4.6.0"
+        },
+        "factory-boy": {
+            "hashes": [
+                "sha256:6f25cc4761ac109efd503f096e2ad99421b1159f01a29dbb917359dcd68e08ca",
+                "sha256:d552cb872b310ae78bd7429bf318e42e1e903b1a109e899a523293dfa762ea4f"
+            ],
+            "index": "pypi",
+            "version": "==2.11.1"
+        },
+        "faker": {
+            "hashes": [
+                "sha256:0e9a1227a3a0f3297a485715e72ee6eb77081b17b629367042b586e38c03c867",
+                "sha256:b4840807a94a3bad0217d6ed3f9b65a1cc6e1db1c99e1184673056ae2c0a4c4d"
+            ],
+            "index": "pypi",
+            "version": "==0.8.17"
+        },
+        "more-itertools": {
+            "hashes": [
+                "sha256:2b6b9893337bfd9166bee6a62c2b0c9fe7735dcf85948b387ec8cba30e85d8e8",
+                "sha256:6703844a52d3588f951883005efcf555e49566a48afd4db4e965d69b883980d3",
+                "sha256:a18d870ef2ffca2b8463c0070ad17b5978056f403fb64e3f15fe62a52db21cc0"
+            ],
+            "version": "==4.2.0"
+        },
+        "pluggy": {
+            "hashes": [
+                "sha256:7f8ae7f5bdf75671a718d2daf0a64b7885f74510bcd98b1a0bb420eb9a9d0cff",
+                "sha256:d345c8fe681115900d6da8d048ba67c25df42973bda370783cd58826442dcd7c",
+                "sha256:e160a7fcf25762bb60efc7e171d4497ff1d8d2d75a3d0df7a21b76821ecbf5c5"
+            ],
+            "markers": "python_version != '3.3.*' and python_version != '3.1.*' and python_version != '3.0.*' and python_version != '3.2.*' and python_version >= '2.7'",
+            "version": "==0.6.0"
+        },
+        "py": {
+            "hashes": [
+                "sha256:3fd59af7435864e1a243790d322d763925431213b6b8529c6ca71081ace3bbf7",
+                "sha256:e31fb2767eb657cbde86c454f02e99cb846d3cd9d61b318525140214fdc0e98e"
+            ],
+            "markers": "python_version != '3.3.*' and python_version != '3.1.*' and python_version != '3.2.*' and python_version >= '2.7' and python_version != '3.0.*'",
+            "version": "==1.5.4"
+        },
+        "pytest": {
+            "hashes": [
+                "sha256:0453c8676c2bee6feb0434748b068d5510273a916295fd61d306c4f22fbfd752",
+                "sha256:4b208614ae6d98195430ad6bde03641c78553acee7c83cec2e85d613c0cd383d"
+            ],
+            "index": "pypi",
+            "version": "==3.6.3"
+        },
+        "python-dateutil": {
+            "hashes": [
+                "sha256:1adb80e7a782c12e52ef9a8182bebeb73f1d7e24e374397af06fb4956c8dc5c0",
+                "sha256:e27001de32f627c22380a688bcc43ce83504a7bc5da472209b4c70f02829f0b8"
+            ],
+            "version": "==2.7.3"
+        },
+        "six": {
+            "hashes": [
+                "sha256:70e8a77beed4562e7f14fe23a786b54f6296e34344c23bc42f07b15018ff98e9",
+                "sha256:832dc0e10feb1aa2c68dcc57dbb658f1c7e65b9b61af69048abc87a2db00a0eb"
+            ],
+            "version": "==1.11.0"
+        },
+        "text-unidecode": {
+            "hashes": [
+                "sha256:5a1375bb2ba7968740508ae38d92e1f889a0832913cb1c447d5e2046061a396d",
+                "sha256:801e38bd550b943563660a91de8d4b6fa5df60a542be9093f7abf819f86050cc"
+            ],
+            "version": "==1.2"
+        },
+        "waitress": {
+            "hashes": [
+                "sha256:40b0f297a7f3af61fbfbdc67e59090c70dc150a1601c39ecc9f5f1d283fb931b",
+                "sha256:d33cd3d62426c0f1b3cd84ee3d65779c7003aae3fc060dee60524d10a57f05a9"
+            ],
+            "version": "==1.1.0"
+        },
+        "webob": {
+            "hashes": [
+                "sha256:1fe722f2ab857685fc96edec567dc40b1875b21219b3b348e58cd8c4d5ea7df3",
+                "sha256:263690003a3e092ca1ec4df787f93feb0004e39d7bac9cba2c19a552c765894b"
+            ],
+            "markers": "python_version != '3.1.*' and python_version >= '2.7' and python_version != '3.0.*' and python_version != '3.2.*'",
+            "version": "==1.8.2"
+        },
+        "webtest": {
+            "hashes": [
+                "sha256:0c08a44bb03dcb2f5ca61d40bd5b4638e74a564d4ec7848098f419a5fa078dfe",
+                "sha256:5c69f73cc58bef355e919ff96054b68cbaecc7d970b60b602568d3d92ca967d5"
+            ],
+            "index": "pypi",
+            "version": "==2.0.30"
+        }
+    }
+}
diff --git a/Procfile b/Procfile
new file mode 100644
index 0000000..60df632
--- /dev/null
+++ b/Procfile
@@ -0,0 +1 @@
+web: gunicorn autoapp:app -b 0.0.0.0:$PORT -w 3
diff --git a/Readme.md b/Readme.md
new file mode 100644
index 0000000..f0132d3
--- /dev/null
+++ b/Readme.md
@@ -0,0 +1,64 @@
+
+## Install
+
+Before running shell commands, set the `CONDUIT_SECRET`, `FLASK_APP` and `FLASK_DEBUG` environment variables :
+```bash
+export CONDUIT_SECRET='something-really-secret'
+export FLASK_APP=/path/to/autoapp.py
+export FLASK_DEBUG=1
+```
+
+- be sure to have python 3+
+- have postgresql installed on your machine
+- `pip install -r requirements/dev.txt --user`
+
+
+## Applying db schema :
+```bash
+flask db init
+flask db migrate
+flask db upgrade
+```
+
+
+Whenever a database migration needs to be made. Run the following commands
+
+`flask db migrate`
+
+This will generate a new migration script. Then run `flask db` upgrade
+
+To apply the migration.
+
+For a full migration command reference, run `flask db --help`.
+
+## Running tests with docker : 
+
+```bash
+docker container run --name flask_db_test -e POSTGRES_PASSWORD=somePwd -e POSTGRES_USER=myUsr -p 5432:5432 -d postgres
+sleep 1
+export DATABASE_URL=postgresql://myUsr:somePwd@localhost:5432/myUsr
+flask db upgrade
+flask test
+docker container stop flask_db_test
+docker container rm flask_db_test
+unset DATABASE_URL
+```
+
+## Usage in prod :
+
+```
+gunicorn autoapp:app -b 0.0.0.0:$PORT -w 3
+```
+
+## Shell
+
+To open the interactive shell, run `flask shell`.
+
+By default, you will have access to the flask ``app`` and models.
+
+## Dev
+
+In your production environment, make sure the `FLASK_DEBUG` environment
+variable is unset or is set to ``0``, so that `ProdConfig` is used, and
+set `DATABASE_URL` which is your postgresql URI like for example 
+`postgresql://localhost/example`
diff --git a/Vagrantfile b/Vagrantfile
new file mode 100644
index 0000000..e976170
--- /dev/null
+++ b/Vagrantfile
@@ -0,0 +1,103 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+# Postgres config based on Davis Ford's config: https://gist.github.com/davisford/8000332
+
+$script = <<SCRIPT
+    #!/usr/bin/env bash
+
+    # Update package list
+
+    echo "Updating packages list"
+    sudo add-apt-repository -y ppa:deadsnakes/ppa
+    sudo apt-get update
+
+    # Install necessary packages
+    echo "Installing python and postgres"
+    sudo apt-get install -y python3.7 python3-pip postgresql-10  
+
+    # Setting postgres config
+    echo "Fixing listen_addresses on postgresql.conf"
+    sudo sed -i "s/#listen_address.*/listen_addresses '*'/" /etc/postgresql/9.5/main/postgresql.conf
+    echo "Fixing postgres pg_hba.conf file"
+    
+    # Replace the ipv4 host line with the above line
+    sudo cat >> /etc/postgresql/9.5/main/pg_hba.conf << EOF
+    # Accept all IPv4 connections - FOR DEVELOPMENT ONLY!!!
+    host    all         all         0.0.0.0/0             md5
+EOF
+    echo "Creating postgres vagrant role with password vagrant"
+    # Create Role and login
+    sudo -i -u postgres psql -c "create role vagrant with superuser login password 'vagrant';"
+
+    #Install requeriments, assuming you have your Pipfile in the shared folder. If not, pipenv will create a new
+    # virtual environment and a new Pipfile
+    echo "Installing project dependencies"
+    python3.7 -m pip install pipenv
+    cd /vagrant
+    python3.7 -m pipenv install --dev
+SCRIPT
+
+# All Vagrant configuration is done below. The "2" in Vagrant.configure
+# configures the configuration version (we support older styles for
+# backwards compatibility). Please don't change it unless you know what
+# you're doing.
+Vagrant.configure("2") do |config|
+  # The most common configuration options are documented and commented below.
+  # For a complete reference, please see the online documentation at
+  # https://docs.vagrantup.com.
+
+  # Every Vagrant development environment requires a box. You can search for
+  # boxes at https://vagrantcloud.com/search.
+  config.vm.box = "bento/ubuntu-18.04"
+
+  # Disable automatic box update checking. If you disable this, then
+  # boxes will only be checked for updates when the user runs
+  # `vagrant box outdated`. This is not recommended.
+  # config.vm.box_check_update = false
+
+  # Create a forwarded port mapping which allows access to a specific port
+  # within the machine from a port on the host machine. In the example below,
+  # accessing "localhost:8080" will access port 80 on the guest machine.
+  # NOTE: This will enable public access to the opened port
+  # config.vm.network "forwarded_port", guest: 80, host: 8080
+
+  # Create a forwarded port mapping which allows access to a specific port
+  # within the machine from a port on the host machine and only allow access
+  # via 127.0.0.1 to disable public access
+  config.vm.network "forwarded_port", guest: 5432, host: 55432, host_ip: "127.0.0.1"
+
+  # Create a private network, which allows host-only access to the machine
+  # using a specific IP.
+  # config.vm.network "private_network", ip: "192.168.33.10"
+
+  # Create a public network, which generally matched to bridged network.
+  # Bridged networks make the machine appear as another physical device on
+  # your network.
+  # config.vm.network "public_network"
+
+  # Share an additional folder to the guest VM. The first argument is
+  # the path on the host to the actual folder. The second argument is
+  # the path on the guest to mount the folder. And the optional third
+  # argument is a set of non-required options.
+  # config.vm.synced_folder "../data", "/vagrant_data"
+
+  # Provider-specific configuration so you can fine-tune various
+  # backing providers for Vagrant. These expose provider-specific options.
+  # Example for VirtualBox:
+  #
+  # config.vm.provider "virtualbox" do |vb|
+  #   # Display the VirtualBox GUI when booting the machine
+  #   vb.gui = true
+  #
+  #   # Customize the amount of memory on the VM:
+  #   vb.memory = "1024"
+  # end
+  #
+  # View the documentation for the provider you are using for more
+  # information on available options.
+
+  # Enable provisioning with a shell script. Additional provisioners such as
+  # Puppet, Chef, Ansible, Salt, and Docker are also available. Please see the
+  # documentation for more information about their specific syntax and use.
+  config.vm.provision :shell, inline: $script
+end
diff --git a/autoapp.py b/autoapp.py
new file mode 100755
index 0000000..e3a50c4
--- /dev/null
+++ b/autoapp.py
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""Create an application instance."""
+from flask.helpers import get_debug_flag
+
+from conduit.app import create_app
+from conduit.settings import DevConfig, ProdConfig
+
+CONFIG = DevConfig if get_debug_flag() else ProdConfig
+
+app = create_app(CONFIG)
diff --git a/conduit/__init__.py b/conduit/__init__.py
new file mode 100644
index 0000000..5b52f8c
--- /dev/null
+++ b/conduit/__init__.py
@@ -0,0 +1 @@
+"""Main application package."""
diff --git a/conduit/app.py b/conduit/app.py
new file mode 100644
index 0000000..8f84ee8
--- /dev/null
+++ b/conduit/app.py
@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+"""The app module, containing the app factory function."""
+from flask import Flask
+from conduit.extensions import bcrypt, cache, db, migrate, jwt, cors
+
+from conduit import commands, user, profile, articles
+from conduit.settings import ProdConfig
+from conduit.exceptions import InvalidUsage
+
+
+def create_app(config_object=ProdConfig):
+    """An application factory, as explained here:
+    http://flask.pocoo.org/docs/patterns/appfactories/.
+
+    :param config_object: The configuration object to use.
+    """
+    app = Flask(__name__.split('.')[0])
+    app.url_map.strict_slashes = False
+    app.config.from_object(config_object)
+    register_extensions(app)
+    register_blueprints(app)
+    register_errorhandlers(app)
+    register_shellcontext(app)
+    register_commands(app)
+    return app
+
+
+def register_extensions(app):
+    """Register Flask extensions."""
+    bcrypt.init_app(app)
+    cache.init_app(app)
+    db.init_app(app)
+    migrate.init_app(app, db)
+    jwt.init_app(app)
+
+
+def register_blueprints(app):
+    """Register Flask blueprints."""
+    origins = app.config.get('CORS_ORIGIN_WHITELIST', '*')
+    cors.init_app(user.views.blueprint, origins=origins)
+    cors.init_app(profile.views.blueprint, origins=origins)
+    cors.init_app(articles.views.blueprint, origins=origins)
+
+    app.register_blueprint(user.views.blueprint)
+    app.register_blueprint(profile.views.blueprint)
+    app.register_blueprint(articles.views.blueprint)
+
+
+def register_errorhandlers(app):
+
+    def errorhandler(error):
+        response = error.to_json()
+        response.status_code = error.status_code
+        return response
+
+    app.errorhandler(InvalidUsage)(errorhandler)
+
+
+def register_shellcontext(app):
+    """Register shell context objects."""
+    def shell_context():
+        """Shell context objects."""
+        return {
+            'db': db,
+            'User': user.models.User,
+            'UserProfile': profile.models.UserProfile,
+            'Article': articles.models.Article,
+            'Tag': articles.models.Tags,
+            'Comment': articles.models.Comment,
+        }
+
+    app.shell_context_processor(shell_context)
+
+
+def register_commands(app):
+    """Register Click commands."""
+    app.cli.add_command(commands.test)
+    app.cli.add_command(commands.lint)
+    app.cli.add_command(commands.clean)
+    app.cli.add_command(commands.urls)
diff --git a/conduit/articles/__init__.py b/conduit/articles/__init__.py
new file mode 100644
index 0000000..373753f
--- /dev/null
+++ b/conduit/articles/__init__.py
@@ -0,0 +1,3 @@
+# coding: utf-8
+
+from . import views  # noqa
diff --git a/conduit/articles/models.py b/conduit/articles/models.py
new file mode 100644
index 0000000..69b2267
--- /dev/null
+++ b/conduit/articles/models.py
@@ -0,0 +1,112 @@
+# coding: utf-8
+
+import datetime as dt
+
+from flask_jwt_extended import current_user
+from slugify import slugify
+
+from conduit.database import (Model, SurrogatePK, db, Column,
+                              reference_col, relationship)
+from conduit.profile.models import UserProfile
+
+favoriter_assoc = db.Table("favoritor_assoc",
+                           db.Column("favoriter", db.Integer, db.ForeignKey("userprofile.id")),
+                           db.Column("favorited_article", db.Integer, db.ForeignKey("article.id")))
+
+tag_assoc = db.Table("tag_assoc",
+                     db.Column("tag", db.Integer, db.ForeignKey("tags.id")),
+                     db.Column("article", db.Integer, db.ForeignKey("article.id")))
+
+
+class Tags(Model):
+    __tablename__ = 'tags'
+
+    id = db.Column(db.Integer, primary_key=True)
+    tagname = db.Column(db.String(100))
+
+    def __init__(self, tagname):
+        db.Model.__init__(self, tagname=tagname)
+
+    def __repr__(self):
+        return self.tagname
+
+
+class Comment(Model, SurrogatePK):
+    __tablename__ = 'comment'
+
+    id = db.Column(db.Integer, primary_key=True)
+    body = Column(db.Text)
+    createdAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
+    updatedAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
+    author_id = reference_col('userprofile', nullable=False)
+    author = relationship('UserProfile', backref=db.backref('comments'))
+    article_id = reference_col('article', nullable=False)
+
+    def __init__(self, article, author, body, **kwargs):
+        db.Model.__init__(self, author=author, body=body, article=article, **kwargs)
+
+
+class Article(SurrogatePK, Model):
+    __tablename__ = 'article'
+
+    id = db.Column(db.Integer, primary_key=True)
+    slug = Column(db.Text, unique=True)
+    title = Column(db.String(100), nullable=False)
+    description = Column(db.Text, nullable=False)
+    body = Column(db.Text)
+    createdAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
+    updatedAt = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
+    author_id = reference_col('userprofile', nullable=False)
+    author = relationship('UserProfile', backref=db.backref('articles'))
+    favoriters = relationship(
+        'UserProfile',
+        secondary=favoriter_assoc,
+        backref='favorites',
+        lazy='dynamic')
+
+    tagList = relationship(
+        'Tags', secondary=tag_assoc, backref='articles')
+
+    comments = relationship('Comment', backref=db.backref('article'), lazy='dynamic')
+
+    def __init__(self, author, title, body, description, slug=None, **kwargs):
+        db.Model.__init__(self, author=author, title=title, description=description, body=body,
+                          slug=slug or slugify(title), **kwargs)
+
+    def favourite(self, profile):
+        if not self.is_favourite(profile):
+            self.favoriters.append(profile)
+            return True
+        return False
+
+    def unfavourite(self, profile):
+        if self.is_favourite(profile):
+            self.favoriters.remove(profile)
+            return True
+        return False
+
+    def is_favourite(self, profile):
+        return bool(self.query.filter(favoriter_assoc.c.favoriter == profile.id).count())
+
+    def add_tag(self, tag):
+        if tag not in self.tagList:
+            self.tagList.append(tag)
+            return True
+        return False
+
+    def remove_tag(self, tag):
+        if tag in self.tagList:
+            self.tagList.remove(tag)
+            return True
+        return False
+
+    @property
+    def favoritesCount(self):
+        return len(self.favoriters.all())
+
+    @property
+    def favorited(self):
+        if current_user:
+            profile = current_user.profile
+            return self.query.join(Article.favoriters).filter(UserProfile.id == profile.id).count() == 1
+        return False
diff --git a/conduit/articles/serializers.py b/conduit/articles/serializers.py
new file mode 100644
index 0000000..d21ea62
--- /dev/null
+++ b/conduit/articles/serializers.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+from marshmallow import Schema, fields, pre_load, post_dump
+
+from conduit.profile.serializers import ProfileSchema
+
+
+class TagSchema(Schema):
+    tagname = fields.Str()
+
+
+class ArticleSchema(Schema):
+    slug = fields.Str()
+    title = fields.Str()
+    description = fields.Str()
+    createdAt = fields.DateTime()
+    body = fields.Str()
+    updatedAt = fields.DateTime(dump_only=True)
+    author = fields.Nested(ProfileSchema)
+    article = fields.Nested('self', exclude=('article',), default=True, load_only=True)
+    tagList = fields.List(fields.Str())
+    favoritesCount = fields.Int(dump_only=True)
+    favorited = fields.Bool(dump_only=True)
+
+    @pre_load
+    def make_article(self, data, **kwargs):
+        return data['article']
+
+    @post_dump
+    def dump_article(self, data, **kwargs):
+        data['author'] = data['author']['profile']
+        return {'article': data}
+
+    class Meta:
+        strict = True
+
+
+class ArticleSchemas(ArticleSchema):
+
+    @post_dump
+    def dump_article(self, data, **kwargs):
+        data['author'] = data['author']['profile']
+        return data
+
+    @post_dump(pass_many=True)
+    def dump_articles(self, data, many, **kwargs):
+        return {'articles': data, 'articlesCount': len(data)}
+
+
+class CommentSchema(Schema):
+    createdAt = fields.DateTime()
+    body = fields.Str()
+    updatedAt = fields.DateTime(dump_only=True)
+    author = fields.Nested(ProfileSchema)
+    id = fields.Int()
+
+    # for the envelope
+    comment = fields.Nested('self', exclude=('comment',), default=True, load_only=True)
+
+    @pre_load
+    def make_comment(self, data, **kwargs):
+        return data['comment']
+
+    @post_dump
+    def dump_comment(self, data, **kwargs):
+        data['author'] = data['author']['profile']
+        return {'comment': data}
+
+    class Meta:
+        strict = True
+
+
+class CommentsSchema(CommentSchema):
+
+    @post_dump
+    def dump_comment(self, data, **kwargs):
+        data['author'] = data['author']['profile']
+        return data
+
+    @post_dump(pass_many=True)
+    def make_comment(self, data, many, **kwargs):
+        return {'comments': data}
+
+
+article_schema = ArticleSchema()
+articles_schema = ArticleSchemas(many=True)
+comment_schema = CommentSchema()
+comments_schema = CommentsSchema(many=True)
diff --git a/conduit/articles/views.py b/conduit/articles/views.py
new file mode 100644
index 0000000..1866ee7
--- /dev/null
+++ b/conduit/articles/views.py
@@ -0,0 +1,168 @@
+# coding: utf-8
+
+import datetime as dt
+
+from flask import Blueprint, jsonify
+from flask_apispec import marshal_with, use_kwargs
+from flask_jwt_extended import current_user, jwt_required, jwt_optional
+from marshmallow import fields
+
+from conduit.exceptions import InvalidUsage
+from conduit.user.models import User
+from .models import Article, Tags, Comment
+from .serializers import (article_schema, articles_schema, comment_schema,
+                          comments_schema)
+
+blueprint = Blueprint('articles', __name__)
+
+
+##########
+# Articles
+##########
+
+@blueprint.route('/api/articles', methods=('GET',))
+@jwt_optional
+@use_kwargs({'tag': fields.Str(), 'author': fields.Str(),
+             'favorited': fields.Str(), 'limit': fields.Int(), 'offset': fields.Int()})
+@marshal_with(articles_schema)
+def get_articles(tag=None, author=None, favorited=None, limit=20, offset=0):
+    res = Article.query
+    if tag:
+        res = res.filter(Article.tagList.any(Tags.tagname == tag))
+    if author:
+        res = res.join(Article.author).join(User).filter(User.username == author)
+    if favorited:
+        res = res.join(Article.favoriters).filter(User.username == favorited)
+    return res.offset(offset).limit(limit).all()
+
+
+@blueprint.route('/api/articles', methods=('POST',))
+@jwt_required
+@use_kwargs(article_schema)
+@marshal_with(article_schema)
+def make_article(body, title, description, tagList=None):
+    article = Article(title=title, description=description, body=body,
+                      author=current_user.profile)
+    if tagList is not None:
+        for tag in tagList:
+            mtag = Tags.query.filter_by(tagname=tag).first()
+            if not mtag:
+                mtag = Tags(tag)
+                mtag.save()
+            article.add_tag(mtag)
+    article.save()
+    return article
+
+
+@blueprint.route('/api/articles/<slug>', methods=('PUT',))
+@jwt_required
+@use_kwargs(article_schema)
+@marshal_with(article_schema)
+def update_article(slug, **kwargs):
+    article = Article.query.filter_by(slug=slug, author_id=current_user.profile.id).first()
+    if not article:
+        raise InvalidUsage.article_not_found()
+    article.update(updatedAt=dt.datetime.utcnow(), **kwargs)
+    article.save()
+    return article
+
+
+@blueprint.route('/api/articles/<slug>', methods=('DELETE',))
+@jwt_required
+def delete_article(slug):
+    article = Article.query.filter_by(slug=slug, author_id=current_user.profile.id).first()
+    article.delete()
+    return '', 200
+
+
+@blueprint.route('/api/articles/<slug>', methods=('GET',))
+@jwt_optional
+@marshal_with(article_schema)
+def get_article(slug):
+    article = Article.query.filter_by(slug=slug).first()
+    if not article:
+        raise InvalidUsage.article_not_found()
+    return article
+
+
+@blueprint.route('/api/articles/<slug>/favorite', methods=('POST',))
+@jwt_required
+@marshal_with(article_schema)
+def favorite_an_article(slug):
+    profile = current_user.profile
+    article = Article.query.filter_by(slug=slug).first()
+    if not article:
+        raise InvalidUsage.article_not_found()
+    article.favourite(profile)
+    article.save()
+    return article
+
+
+@blueprint.route('/api/articles/<slug>/favorite', methods=('DELETE',))
+@jwt_required
+@marshal_with(article_schema)
+def unfavorite_an_article(slug):
+    profile = current_user.profile
+    article = Article.query.filter_by(slug=slug).first()
+    if not article:
+        raise InvalidUsage.article_not_found()
+    article.unfavourite(profile)
+    article.save()
+    return article
+
+
+@blueprint.route('/api/articles/feed', methods=('GET',))
+@jwt_required
+@use_kwargs({'limit': fields.Int(), 'offset': fields.Int()})
+@marshal_with(articles_schema)
+def articles_feed(limit=20, offset=0):
+    return Article.query.join(current_user.profile.follows). \
+        order_by(Article.createdAt.desc()).offset(offset).limit(limit).all()
+
+
+######
+# Tags
+######
+
+@blueprint.route('/api/tags', methods=('GET',))
+def get_tags():
+    return jsonify({'tags': [tag.tagname for tag in Tags.query.all()]})
+
+
+##########
+# Comments
+##########
+
+
+@blueprint.route('/api/articles/<slug>/comments', methods=('GET',))
+@marshal_with(comments_schema)
+def get_comments(slug):
+    article = Article.query.filter_by(slug=slug).first()
+    if not article:
+        raise InvalidUsage.article_not_found()
+    return article.comments
+
+
+@blueprint.route('/api/articles/<slug>/comments', methods=('POST',))
+@jwt_required
+@use_kwargs(comment_schema)
+@marshal_with(comment_schema)
+def make_comment_on_article(slug, body, **kwargs):
+    article = Article.query.filter_by(slug=slug).first()
+    if not article:
+        raise InvalidUsage.article_not_found()
+    comment = Comment(article, current_user.profile, body, **kwargs)
+    comment.save()
+    return comment
+
+
+@blueprint.route('/api/articles/<slug>/comments/<cid>', methods=('DELETE',))
+@jwt_required
+def delete_comment_on_article(slug, cid):
+    article = Article.query.filter_by(slug=slug).first()
+    if not article:
+        raise InvalidUsage.article_not_found()
+
+    comment = article.comments.filter_by(id=cid, author=current_user.profile).first()
+    comment.delete()
+    return '', 200
diff --git a/conduit/commands.py b/conduit/commands.py
new file mode 100644
index 0000000..e941ee2
--- /dev/null
+++ b/conduit/commands.py
@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""Click commands."""
+import os
+from glob import glob
+from subprocess import call
+
+import click
+from flask import current_app
+from flask.cli import with_appcontext
+from werkzeug.exceptions import MethodNotAllowed, NotFound
+
+HERE = os.path.abspath(os.path.dirname(__file__))
+PROJECT_ROOT = os.path.join(HERE, os.pardir)
+TEST_PATH = os.path.join(PROJECT_ROOT, 'tests')
+
+
+@click.command()
+def test():
+    """Run the tests."""
+    import pytest
+    rv = pytest.main([TEST_PATH, '--verbose'])
+    exit(rv)
+
+
+@click.command()
+@click.option('-f', '--fix-imports', default=False, is_flag=True,
+              help='Fix imports using isort, before linting')
+def lint(fix_imports):
+    """Lint and check code style with flake8 and isort."""
+    skip = ['requirements']
+    root_files = glob('*.py')
+    root_directories = [
+        name for name in next(os.walk('.'))[1] if not name.startswith('.')]
+    files_and_directories = [
+        arg for arg in root_files + root_directories if arg not in skip]
+
+    def execute_tool(description, *args):
+        """Execute a checking tool with its arguments."""
+        command_line = list(args) + files_and_directories
+        click.echo('{}: {}'.format(description, ' '.join(command_line)))
+        rv = call(command_line)
+        if rv != 0:
+            exit(rv)
+
+    if fix_imports:
+        execute_tool('Fixing import order', 'isort', '-rc')
+    execute_tool('Checking code style', 'flake8')
+
+
+@click.command()
+def clean():
+    """Remove *.pyc and *.pyo files recursively starting at current directory.
+
+    Borrowed from Flask-Script, converted to use Click.
+    """
+    for dirpath, _, filenames in os.walk('.'):
+        for filename in filenames:
+            if filename.endswith('.pyc') or filename.endswith('.pyo'):
+                full_pathname = os.path.join(dirpath, filename)
+                click.echo('Removing {}'.format(full_pathname))
+                os.remove(full_pathname)
+
+
+@click.command()
+@click.option('--url', default=None,
+              help='Url to test (ex. /static/image.png)')
+@click.option('--order', default='rule',
+              help='Property on Rule to order by (default: rule)')
+@with_appcontext
+def urls(url, order):
+    """Display all of the url matching routes for the project.
+
+    Borrowed from Flask-Script, converted to use Click.
+    """
+    rows = []
+    column_headers = ('Rule', 'Endpoint', 'Arguments')
+
+    if url:
+        try:
+            rule, arguments = (
+                current_app.url_map.bind('localhost')
+                .match(url, return_rule=True))
+            rows.append((rule.rule, rule.endpoint, arguments))
+            column_length = 3
+        except (NotFound, MethodNotAllowed) as e:
+            rows.append(('<{}>'.format(e), None, None))
+            column_length = 1
+    else:
+        rules = sorted(
+            current_app.url_map.iter_rules(),
+            key=lambda rule: getattr(rule, order))
+        for rule in rules:
+            rows.append((rule.rule, rule.endpoint, None))
+        column_length = 2
+
+    str_template = ''
+    table_width = 0
+
+    if column_length >= 1:
+        max_rule_length = max(len(r[0]) for r in rows)
+        max_rule_length = max_rule_length if max_rule_length > 4 else 4
+        str_template += '{:' + str(max_rule_length) + '}'
+        table_width += max_rule_length
+
+    if column_length >= 2:
+        max_endpoint_length = max(len(str(r[1])) for r in rows)
+        max_endpoint_length = (
+            max_endpoint_length if max_endpoint_length > 8 else 8)
+        str_template += '  {:' + str(max_endpoint_length) + '}'
+        table_width += 2 + max_endpoint_length
+
+    if column_length >= 3:
+        max_arguments_length = max(len(str(r[2])) for r in rows)
+        max_arguments_length = (
+            max_arguments_length if max_arguments_length > 9 else 9)
+        str_template += '  {:' + str(max_arguments_length) + '}'
+        table_width += 2 + max_arguments_length
+
+    click.echo(str_template.format(*column_headers[:column_length]))
+    click.echo('-' * table_width)
+
+    for row in rows:
+        click.echo(str_template.format(*row[:column_length]))
diff --git a/conduit/compat.py b/conduit/compat.py
new file mode 100644
index 0000000..2833e72
--- /dev/null
+++ b/conduit/compat.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+"""Python 2/3 compatibility module."""
+import sys
+
+PY2 = int(sys.version[0]) == 2
+
+if PY2:
+    text_type = unicode  # noqa
+    binary_type = str
+    string_types = (str, unicode)  # noqa
+    unicode = unicode  # noqa
+    basestring = basestring  # noqa
+else:
+    text_type = str
+    binary_type = bytes
+    string_types = (str,)
+    unicode = str
+    basestring = (str, bytes)
diff --git a/conduit/database.py b/conduit/database.py
new file mode 100644
index 0000000..19ad5d0
--- /dev/null
+++ b/conduit/database.py
@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+"""Database module, including the SQLAlchemy database object and DB-related utilities."""
+from sqlalchemy.orm import relationship
+
+from .compat import basestring
+from .extensions import db
+
+# Alias common SQLAlchemy names
+Column = db.Column
+relationship = relationship
+Model = db.Model
+
+# From Mike Bayer's "Building the app" talk
+# https://speakerdeck.com/zzzeek/building-the-app
+class SurrogatePK(object):
+    """A mixin that adds a surrogate integer 'primary key' column named ``id`` \
+        to any declarative-mapped class.
+    """
+
+    __table_args__ = {'extend_existing': True}
+
+    id = db.Column(db.Integer, primary_key=True)
+
+    @classmethod
+    def get_by_id(cls, record_id):
+        """Get record by ID."""
+        if any(
+                (isinstance(record_id, basestring) and record_id.isdigit(),
+                 isinstance(record_id, (int, float))),
+        ):
+            return cls.query.get(int(record_id))
+
+
+def reference_col(tablename, nullable=False, pk_name='id', **kwargs):
+    """Column that adds primary key foreign key reference.
+
+    Usage: ::
+
+        category_id = reference_col('category')
+        category = relationship('Category', backref='categories')
+    """
+    return db.Column(
+        db.ForeignKey('{0}.{1}'.format(tablename, pk_name)),
+        nullable=nullable, **kwargs)
diff --git a/conduit/exceptions.py b/conduit/exceptions.py
new file mode 100644
index 0000000..eb9ad0c
--- /dev/null
+++ b/conduit/exceptions.py
@@ -0,0 +1,47 @@
+from flask import jsonify
+
+
+def template(data, code=500):
+    return {'message': {'errors': {'body': data}}, 'status_code': code}
+
+
+USER_NOT_FOUND = template(['User not found'], code=404)
+USER_ALREADY_REGISTERED = template(['User already registered'], code=422)
+UNKNOWN_ERROR = template([], code=500)
+ARTICLE_NOT_FOUND = template(['Article not found'], code=404)
+COMMENT_NOT_OWNED = template(['Not your article'], code=422)
+
+
+class InvalidUsage(Exception):
+    status_code = 500
+
+    def __init__(self, message, status_code=None, payload=None):
+        Exception.__init__(self)
+        self.message = message
+        if status_code is not None:
+            self.status_code = status_code
+        self.payload = payload
+
+    def to_json(self):
+        rv = self.message
+        return jsonify(rv)
+
+    @classmethod
+    def user_not_found(cls):
+        return cls(**USER_NOT_FOUND)
+
+    @classmethod
+    def user_already_registered(cls):
+        return cls(**USER_ALREADY_REGISTERED)
+
+    @classmethod
+    def unknown_error(cls):
+        return cls(**UNKNOWN_ERROR)
+
+    @classmethod
+    def article_not_found(cls):
+        return cls(**ARTICLE_NOT_FOUND)
+
+    @classmethod
+    def comment_not_owned(cls):
+        return cls(**COMMENT_NOT_OWNED)
diff --git a/conduit/extensions.py b/conduit/extensions.py
new file mode 100644
index 0000000..ed903b1
--- /dev/null
+++ b/conduit/extensions.py
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""Extensions module. Each extension is initialized in the app factory located in app.py."""
+
+from flask_bcrypt import Bcrypt
+from flask_caching import Cache
+from flask_cors import CORS
+from flask_jwt_extended import JWTManager
+from flask_migrate import Migrate
+from flask_sqlalchemy import SQLAlchemy, Model
+
+
+class CRUDMixin(Model):
+    """Mixin that adds convenience methods for CRUD (create, read, update, delete) operations."""
+
+    @classmethod
+    def create(cls, **kwargs):
+        """Create a new record and save it the database."""
+        instance = cls(**kwargs)
+        return instance.save()
+
+    def update(self, commit=True, **kwargs):
+        """Update specific fields of a record."""
+        for attr, value in kwargs.items():
+            setattr(self, attr, value)
+        return commit and self.save() or self
+
+    def save(self, commit=True):
+        """Save the record."""
+        db.session.add(self)
+        if commit:
+            db.session.commit()
+        return self
+
+    def delete(self, commit=True):
+        """Remove the record from the database."""
+        db.session.delete(self)
+        return commit and db.session.commit()
+
+
+bcrypt = Bcrypt()
+db = SQLAlchemy(model_class=CRUDMixin)
+migrate = Migrate()
+cache = Cache()
+cors = CORS()
+
+from conduit.utils import jwt_identity, identity_loader  # noqa
+
+jwt = JWTManager()
+jwt.user_loader_callback_loader(jwt_identity)
+jwt.user_identity_loader(identity_loader)
diff --git a/conduit/profile/__init__.py b/conduit/profile/__init__.py
new file mode 100644
index 0000000..a515d04
--- /dev/null
+++ b/conduit/profile/__init__.py
@@ -0,0 +1 @@
+from . import views  # noqa
diff --git a/conduit/profile/models.py b/conduit/profile/models.py
new file mode 100644
index 0000000..ea9342b
--- /dev/null
+++ b/conduit/profile/models.py
@@ -0,0 +1,65 @@
+from flask_jwt_extended import current_user
+
+from conduit.database import (Model, SurrogatePK, db,
+                              reference_col, relationship)
+
+
+followers_assoc = db.Table("followers_assoc",
+                           db.Column("follower", db.Integer, db.ForeignKey("userprofile.user_id")),
+                           db.Column("followed_by", db.Integer, db.ForeignKey("userprofile.user_id")))
+
+
+class UserProfile(Model, SurrogatePK):
+    __tablename__ = 'userprofile'
+
+    # id is needed for primary join, it does work with SurrogatePK class
+    id = db.Column(db.Integer, primary_key=True)
+
+    user_id = reference_col('users', nullable=False, unique=True)
+    user = relationship('User', backref=db.backref('profile', uselist=False))
+    follows = relationship('UserProfile',
+                           secondary=followers_assoc,
+                           primaryjoin=id == followers_assoc.c.follower,
+                           secondaryjoin=id == followers_assoc.c.followed_by,
+                           backref='followed_by',
+                           lazy='dynamic')
+
+    def __init__(self, user, **kwargs):
+        db.Model.__init__(self, user=user, **kwargs)
+
+    def is_following(self, profile):
+        return bool(self.follows.filter(followers_assoc.c.followed_by == profile.id).count())
+
+    def follow(self, profile):
+        if self is not profile and not self.is_following(profile):
+            self.follows.append(profile)
+            return True
+        return False
+
+    def unfollow(self, profile):
+        if self is not profile and self.is_following(profile):
+            self.follows.remove(profile)
+            return True
+        return False
+
+    @property
+    def following(self):
+        if current_user:
+            return current_user.profile.is_following(self)
+        return False
+
+    @property
+    def username(self):
+        return self.user.username
+
+    @property
+    def bio(self):
+        return self.user.bio
+
+    @property
+    def image(self):
+        return self.user.image
+
+    @property
+    def email(self):
+        return self.user.email
diff --git a/conduit/profile/serializers.py b/conduit/profile/serializers.py
new file mode 100644
index 0000000..29b7be2
--- /dev/null
+++ b/conduit/profile/serializers.py
@@ -0,0 +1,27 @@
+from marshmallow import Schema, fields, pre_load, post_dump
+
+
+class ProfileSchema(Schema):
+    username = fields.Str()
+    email = fields.Email()
+    password = fields.Str(load_only=True)
+    bio = fields.Str()
+    image = fields.Url()
+    following = fields.Boolean()
+    # ugly hack.
+    profile = fields.Nested('self', exclude=('profile',), default=True, load_only=True)
+
+    @pre_load
+    def make_user(self, data, **kwargs):
+        return data['profile']
+
+    @post_dump
+    def dump_user(self, data, **kwargs):
+        return {'profile': data}
+
+    class Meta:
+        strict = True
+
+
+profile_schema = ProfileSchema()
+profile_schemas = ProfileSchema(many=True)
diff --git a/conduit/profile/views.py b/conduit/profile/views.py
new file mode 100644
index 0000000..2e23eb7
--- /dev/null
+++ b/conduit/profile/views.py
@@ -0,0 +1,45 @@
+# coding: utf-8
+
+from flask import Blueprint
+from flask_apispec import marshal_with
+from flask_jwt_extended import current_user, jwt_required, jwt_optional
+
+from conduit.exceptions import InvalidUsage
+from conduit.user.models import User
+from .serializers import profile_schema
+
+blueprint = Blueprint('profiles', __name__)
+
+
+@blueprint.route('/api/profiles/<username>', methods=('GET',))
+@jwt_optional
+@marshal_with(profile_schema)
+def get_profile(username):
+    user = User.query.filter_by(username=username).first()
+    if not user:
+        raise InvalidUsage.user_not_found()
+    return user.profile
+
+
+@blueprint.route('/api/profiles/<username>/follow', methods=('POST',))
+@jwt_required
+@marshal_with(profile_schema)
+def follow_user(username):
+    user = User.query.filter_by(username=username).first()
+    if not user:
+        raise InvalidUsage.user_not_found()
+    current_user.profile.follow(user.profile)
+    current_user.profile.save()
+    return user.profile
+
+
+@blueprint.route('/api/profiles/<username>/follow', methods=('DELETE',))
+@jwt_required
+@marshal_with(profile_schema)
+def unfollow_user(username):
+    user = User.query.filter_by(username=username).first()
+    if not user:
+        raise InvalidUsage.user_not_found()
+    current_user.profile.unfollow(user.profile)
+    current_user.profile.save()
+    return user.profile
diff --git a/conduit/settings.py b/conduit/settings.py
new file mode 100644
index 0000000..b838a6d
--- /dev/null
+++ b/conduit/settings.py
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+"""Application configuration."""
+import os
+from datetime import timedelta
+
+
+class Config(object):
+    """Base configuration."""
+
+    SECRET_KEY = os.environ.get('CONDUIT_SECRET', 'secret-key')  # TODO: Change me
+    APP_DIR = os.path.abspath(os.path.dirname(__file__))  # This directory
+    PROJECT_ROOT = os.path.abspath(os.path.join(APP_DIR, os.pardir))
+    BCRYPT_LOG_ROUNDS = 13
+    DEBUG_TB_INTERCEPT_REDIRECTS = False
+    CACHE_TYPE = 'simple'  # Can be "memcached", "redis", etc.
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    JWT_AUTH_USERNAME_KEY = 'email'
+    JWT_AUTH_HEADER_PREFIX = 'Token'
+    CORS_ORIGIN_WHITELIST = [
+        'http://0.0.0.0:4100',
+        'http://localhost:4100',
+        'http://0.0.0.0:8000',
+        'http://localhost:8000',
+        'http://0.0.0.0:4200',
+        'http://localhost:4200',
+        'http://0.0.0.0:4000',
+        'http://localhost:4000',
+    ]
+    JWT_HEADER_TYPE = 'Token'
+
+
+class ProdConfig(Config):
+    """Production configuration."""
+
+    ENV = 'prod'
+    DEBUG = False
+    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL',
+                                             'postgresql://localhost/example')
+
+
+class DevConfig(Config):
+    """Development configuration."""
+
+    ENV = 'dev'
+    DEBUG = True
+    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL',
+                                             'postgresql://localhost/example')
+    CACHE_TYPE = 'simple'  # Can be "memcached", "redis", etc.
+    JWT_ACCESS_TOKEN_EXPIRES = timedelta(10 ** 6)
+
+
+class TestConfig(Config):
+    """Test configuration."""
+
+    TESTING = True
+    DEBUG = True
+    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL',
+                                             'postgresql://localhost/example')
+    # For faster tests; needs at least 4 to avoid "ValueError: Invalid rounds"
+    BCRYPT_LOG_ROUNDS = 4
diff --git a/conduit/user/__init__.py b/conduit/user/__init__.py
new file mode 100644
index 0000000..c11ac5e
--- /dev/null
+++ b/conduit/user/__init__.py
@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+"""The user module."""
+from . import views  # noqa
diff --git a/conduit/user/models.py b/conduit/user/models.py
new file mode 100644
index 0000000..c8cfc4e
--- /dev/null
+++ b/conduit/user/models.py
@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+"""User models."""
+import datetime as dt
+
+from conduit.database import Column, Model, SurrogatePK, db
+from conduit.extensions import bcrypt
+
+
+class User(SurrogatePK, Model):
+
+    __tablename__ = 'users'
+    username = Column(db.String(80), unique=True, nullable=False)
+    email = Column(db.String(100), unique=True, nullable=False)
+    password = Column(db.Binary(128), nullable=True)
+    created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
+    updated_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
+    bio = Column(db.String(300), nullable=True)
+    image = Column(db.String(120), nullable=True)
+    token: str = ''
+
+    def __init__(self, username, email, password=None, **kwargs):
+        """Create instance."""
+        db.Model.__init__(self, username=username, email=email, **kwargs)
+        if password:
+            self.set_password(password)
+        else:
+            self.password = None
+
+    def set_password(self, password):
+        """Set password."""
+        self.password = bcrypt.generate_password_hash(password)
+
+    def check_password(self, value):
+        """Check password."""
+        return bcrypt.check_password_hash(self.password, value)
+
+    def __repr__(self):
+        """Represent instance as a unique string."""
+        return '<User({username!r})>'.format(username=self.username)
diff --git a/conduit/user/serializers.py b/conduit/user/serializers.py
new file mode 100644
index 0000000..140b0bb
--- /dev/null
+++ b/conduit/user/serializers.py
@@ -0,0 +1,38 @@
+# coding: utf-8
+
+from marshmallow import Schema, fields, pre_load, post_dump
+
+
+class UserSchema(Schema):
+    username = fields.Str()
+    email = fields.Email()
+    password = fields.Str(load_only=True)
+    bio = fields.Str()
+    image = fields.Url()
+    token = fields.Str(dump_only=True)
+    createdAt = fields.DateTime(attribute='created_at', dump_only=True)
+    updatedAt = fields.DateTime(attribute='updated_at')
+    # ugly hack.
+    user = fields.Nested('self', exclude=('user',), default=True, load_only=True)
+
+    @pre_load
+    def make_user(self, data, **kwargs):
+        data = data['user']
+        # some of the frontends send this like an empty string and some send
+        # null
+        if not data.get('email', True):
+            del data['email']
+        if not data.get('image', True):
+            del data['image']
+        return data
+
+    @post_dump
+    def dump_user(self, data, **kwargs):
+        return {'user': data}
+
+    class Meta:
+        strict = True
+
+
+user_schema = UserSchema()
+user_schemas = UserSchema(many=True)
diff --git a/conduit/user/views.py b/conduit/user/views.py
new file mode 100644
index 0000000..dc56916
--- /dev/null
+++ b/conduit/user/views.py
@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""User views."""
+from flask import Blueprint, request
+from flask_apispec import use_kwargs, marshal_with
+from flask_jwt_extended import jwt_required, jwt_optional, create_access_token, current_user
+from sqlalchemy.exc import IntegrityError
+
+from conduit.database import db
+from conduit.exceptions import InvalidUsage
+from conduit.profile.models import UserProfile
+from .models import User
+from .serializers import user_schema
+
+blueprint = Blueprint('user', __name__)
+
+
+@blueprint.route('/api/users', methods=('POST',))
+@use_kwargs(user_schema)
+@marshal_with(user_schema)
+def register_user(username, password, email, **kwargs):
+    try:
+        userprofile = UserProfile(User(username, email, password=password, **kwargs).save()).save()
+        userprofile.user.token = create_access_token(identity=userprofile.user)
+    except IntegrityError:
+        db.session.rollback()
+        raise InvalidUsage.user_already_registered()
+    return userprofile.user
+
+
+@blueprint.route('/api/users/login', methods=('POST',))
+@jwt_optional
+@use_kwargs(user_schema)
+@marshal_with(user_schema)
+def login_user(email, password, **kwargs):
+    user = User.query.filter_by(email=email).first()
+    if user is not None and user.check_password(password):
+        user.token = create_access_token(identity=user, fresh=True)
+        return user
+    else:
+        raise InvalidUsage.user_not_found()
+
+
+@blueprint.route('/api/user', methods=('GET',))
+@jwt_required
+@marshal_with(user_schema)
+def get_user():
+    user = current_user
+    # Not sure about this
+    user.token = request.headers.environ['HTTP_AUTHORIZATION'].split('Token ')[1]
+    return current_user
+
+
+@blueprint.route('/api/user', methods=('PUT',))
+@jwt_required
+@use_kwargs(user_schema)
+@marshal_with(user_schema)
+def update_user(**kwargs):
+    user = current_user
+    # take in consideration the password
+    password = kwargs.pop('password', None)
+    if password:
+        user.set_password(password)
+    if 'updated_at' in kwargs:
+        kwargs['updated_at'] = user.created_at.replace(tzinfo=None)
+    user.update(**kwargs)
+    return user
diff --git a/conduit/utils.py b/conduit/utils.py
new file mode 100644
index 0000000..4d0f433
--- /dev/null
+++ b/conduit/utils.py
@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+"""Helper utilities and decorators."""
+from conduit.user.models import User  # noqa
+
+
+def jwt_identity(payload):
+    return User.get_by_id(payload)
+
+
+def identity_loader(user):
+    return user.id
diff --git a/image.png b/image.png
new file mode 100644
index 0000000000000000000000000000000000000000..2aed4fc054a5af156cc10c4f54260eeb80c68fc4
GIT binary patch
literal 49006
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

literal 0
HcmV?d00001

diff --git a/migrations/README b/migrations/README
new file mode 100644
index 0000000..98e4f9c
--- /dev/null
+++ b/migrations/README
@@ -0,0 +1 @@
+Generic single-database configuration.
\ No newline at end of file
diff --git a/migrations/alembic.ini b/migrations/alembic.ini
new file mode 100644
index 0000000..f8ed480
--- /dev/null
+++ b/migrations/alembic.ini
@@ -0,0 +1,45 @@
+# A generic, single database configuration.
+
+[alembic]
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
diff --git a/migrations/env.py b/migrations/env.py
new file mode 100644
index 0000000..79b8174
--- /dev/null
+++ b/migrations/env.py
@@ -0,0 +1,96 @@
+from __future__ import with_statement
+
+import logging
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+logger = logging.getLogger('alembic.env')
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+from flask import current_app
+config.set_main_option(
+    'sqlalchemy.url', current_app.config.get(
+        'SQLALCHEMY_DATABASE_URI').replace('%', '%%'))
+target_metadata = current_app.extensions['migrate'].db.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url, target_metadata=target_metadata, literal_binds=True
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+
+    # this callback is used to prevent an auto-migration from being generated
+    # when there are no changes to the schema
+    # reference: http://alembic.zzzcomputing.com/en/latest/cookbook.html
+    def process_revision_directives(context, revision, directives):
+        if getattr(config.cmd_opts, 'autogenerate', False):
+            script = directives[0]
+            if script.upgrade_ops.is_empty():
+                directives[:] = []
+                logger.info('No changes in schema detected.')
+
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix='sqlalchemy.',
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            process_revision_directives=process_revision_directives,
+            **current_app.extensions['migrate'].configure_args
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()
diff --git a/migrations/script.py.mako b/migrations/script.py.mako
new file mode 100644
index 0000000..2c01563
--- /dev/null
+++ b/migrations/script.py.mako
@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}
diff --git a/migrations/versions/2267f00a4594_.py b/migrations/versions/2267f00a4594_.py
new file mode 100644
index 0000000..3b7f481
--- /dev/null
+++ b/migrations/versions/2267f00a4594_.py
@@ -0,0 +1,101 @@
+"""empty message
+
+Revision ID: 2267f00a4594
+Revises: 
+Create Date: 2020-01-04 15:20:33.461410
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '2267f00a4594'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('tags',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('tagname', sa.String(length=100), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_table('users',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('username', sa.String(length=80), nullable=False),
+    sa.Column('email', sa.String(length=100), nullable=False),
+    sa.Column('password', sa.Binary(), nullable=True),
+    sa.Column('created_at', sa.DateTime(), nullable=False),
+    sa.Column('updated_at', sa.DateTime(), nullable=False),
+    sa.Column('bio', sa.String(length=300), nullable=True),
+    sa.Column('image', sa.String(length=120), nullable=True),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('email'),
+    sa.UniqueConstraint('username')
+    )
+    op.create_table('userprofile',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('user_id', sa.Integer(), nullable=False),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('user_id')
+    )
+    op.create_table('article',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('slug', sa.Text(), nullable=True),
+    sa.Column('title', sa.String(length=100), nullable=False),
+    sa.Column('description', sa.Text(), nullable=False),
+    sa.Column('body', sa.Text(), nullable=True),
+    sa.Column('createdAt', sa.DateTime(), nullable=False),
+    sa.Column('updatedAt', sa.DateTime(), nullable=False),
+    sa.Column('author_id', sa.Integer(), nullable=False),
+    sa.ForeignKeyConstraint(['author_id'], ['userprofile.id'], ),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('slug')
+    )
+    op.create_table('followers_assoc',
+    sa.Column('follower', sa.Integer(), nullable=True),
+    sa.Column('followed_by', sa.Integer(), nullable=True),
+    sa.ForeignKeyConstraint(['followed_by'], ['userprofile.user_id'], ),
+    sa.ForeignKeyConstraint(['follower'], ['userprofile.user_id'], )
+    )
+    op.create_table('comment',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('body', sa.Text(), nullable=True),
+    sa.Column('createdAt', sa.DateTime(), nullable=False),
+    sa.Column('updatedAt', sa.DateTime(), nullable=False),
+    sa.Column('author_id', sa.Integer(), nullable=False),
+    sa.Column('article_id', sa.Integer(), nullable=False),
+    sa.ForeignKeyConstraint(['article_id'], ['article.id'], ),
+    sa.ForeignKeyConstraint(['author_id'], ['userprofile.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_table('favoritor_assoc',
+    sa.Column('favoriter', sa.Integer(), nullable=True),
+    sa.Column('favorited_article', sa.Integer(), nullable=True),
+    sa.ForeignKeyConstraint(['favorited_article'], ['article.id'], ),
+    sa.ForeignKeyConstraint(['favoriter'], ['userprofile.id'], )
+    )
+    op.create_table('tag_assoc',
+    sa.Column('tag', sa.Integer(), nullable=True),
+    sa.Column('article', sa.Integer(), nullable=True),
+    sa.ForeignKeyConstraint(['article'], ['article.id'], ),
+    sa.ForeignKeyConstraint(['tag'], ['tags.id'], )
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('tag_assoc')
+    op.drop_table('favoritor_assoc')
+    op.drop_table('comment')
+    op.drop_table('followers_assoc')
+    op.drop_table('article')
+    op.drop_table('userprofile')
+    op.drop_table('users')
+    op.drop_table('tags')
+    # ### end Alembic commands ###
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..82db41e
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,3 @@
+# Included because many Paas's require a requirements.txt file in the project root
+# Just installs the production requirements.
+-r requirements/prod.txt
\ No newline at end of file
diff --git a/requirements/dev.txt b/requirements/dev.txt
new file mode 100644
index 0000000..621b3d3
--- /dev/null
+++ b/requirements/dev.txt
@@ -0,0 +1,9 @@
+# Everything the developer needs in addition to the production requirements
+-r prod.txt
+
+# Testing
+pytest
+WebTest
+factory-boy
+# For python 3
+Faker
diff --git a/requirements/prod.txt b/requirements/prod.txt
new file mode 100644
index 0000000..19a1d8e
--- /dev/null
+++ b/requirements/prod.txt
@@ -0,0 +1,18 @@
+# Everything needed in production
+
+Werkzeug
+SQLAlchemy==1.1.9
+Flask_Caching
+Flask_SQLAlchemy==2.2
+click
+marshmallow
+Flask_Bcrypt
+flask_apispec
+Flask
+PyJWT
+Flask-JWT-Extended
+unicode_slugify
+psycopg2
+Flask-Migrate
+gunicorn
+Flask-Cors
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..aa079ec
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,2 @@
+[flake8]
+max-line-length=120
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..b0c2ab8
--- /dev/null
+++ b/tests/__init__.py
@@ -0,0 +1 @@
+"""Tests for the app."""
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..9dcefdb
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+"""Defines fixtures available to all tests."""
+
+import pytest
+from webtest import TestApp
+
+from conduit.app import create_app
+from conduit.database import db as _db
+from conduit.settings import TestConfig
+from conduit.profile.models import UserProfile
+
+
+from .factories import UserFactory
+
+
+@pytest.yield_fixture(scope='function')
+def app():
+    """An application for the tests."""
+    _app = create_app(TestConfig)
+
+    with _app.app_context():
+        _db.create_all()
+
+    ctx = _app.test_request_context()
+    ctx.push()
+
+    yield _app
+
+    ctx.pop()
+
+
+@pytest.fixture(scope='function')
+def testapp(app):
+    """A Webtest app."""
+    return TestApp(app)
+
+
+@pytest.yield_fixture(scope='function')
+def db(app):
+    """A database for the tests."""
+    _db.app = app
+    with app.app_context():
+        _db.create_all()
+
+    yield _db
+
+    # Explicitly close DB connection
+    _db.session.close()
+    _db.drop_all()
+
+
+@pytest.fixture
+def user(db):
+    """A user for the tests."""
+    class User():
+        def get(self):
+            muser = UserFactory(password='myprecious')
+            UserProfile(muser).save()
+            db.session.commit()
+            return muser
+    return User()
diff --git a/tests/factories.py b/tests/factories.py
new file mode 100644
index 0000000..b7f9c34
--- /dev/null
+++ b/tests/factories.py
@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+"""Factories to help in tests."""
+from factory import PostGenerationMethodCall, Sequence
+from factory.alchemy import SQLAlchemyModelFactory
+
+from conduit.database import db
+from conduit.user.models import User
+
+
+class BaseFactory(SQLAlchemyModelFactory):
+    """Base factory."""
+
+    class Meta:
+        """Factory configuration."""
+
+        abstract = True
+        sqlalchemy_session = db.session
+
+
+class UserFactory(BaseFactory):
+    """User factory."""
+
+    username = Sequence(lambda n: 'user{0}'.format(n))
+    email = Sequence(lambda n: 'user{0}@example.com'.format(n))
+    password = PostGenerationMethodCall('set_password', 'example')
+
+    class Meta:
+        """Factory configuration."""
+
+        model = User
diff --git a/tests/test_articles.py b/tests/test_articles.py
new file mode 100644
index 0000000..50d0f68
--- /dev/null
+++ b/tests/test_articles.py
@@ -0,0 +1,136 @@
+# coding: utf-8
+
+from flask import url_for
+from datetime import datetime
+
+class TestArticleViews:
+
+    def test_get_articles_by_author(self, testapp, user):
+        user = user.get()
+        resp = testapp.post_json(url_for('user.login_user'), {'user': {
+            'email': user.email,
+            'password': 'myprecious'
+        }})
+
+        token = str(resp.json['user']['token'])
+        for _ in range(2):
+            testapp.post_json(url_for('articles.make_article'), {
+                "article": {
+                    "title": "How to train your dragon {}".format(_),
+                    "description": "Ever wonder how?",
+                    "body": "You have to believe",
+                    "tagList": ["reactjs", "angularjs", "dragons"]
+                }
+            }, headers={
+                'Authorization': 'Token {}'.format(token)
+            })
+
+        resp = testapp.get(url_for('articles.get_articles', author=user.username))
+        assert len(resp.json['articles']) == 2
+
+    def test_favorite_an_article(self, testapp, user):
+        user = user.get()
+        resp = testapp.post_json(url_for('user.login_user'), {'user': {
+            'email': user.email,
+            'password': 'myprecious'
+        }})
+
+        token = str(resp.json['user']['token'])
+        resp1 = testapp.post_json(url_for('articles.make_article'), {
+            "article": {
+                "title": "How to train your dragon",
+                "description": "Ever wonder how?",
+                "body": "You have to believe",
+                "tagList": ["reactjs", "angularjs", "dragons"]
+            }
+        }, headers={
+            'Authorization': 'Token {}'.format(token)
+        })
+
+        resp = testapp.post(url_for('articles.favorite_an_article',
+                                    slug=resp1.json['article']['slug']),
+                            headers={
+                                'Authorization': 'Token {}'.format(token)
+                                }
+                           )
+        assert resp.json['article']['favorited']
+
+    def test_get_articles_by_favoriter(self, testapp, user):
+        user = user.get()
+        resp = testapp.post_json(url_for('user.login_user'), {'user': {
+            'email': user.email,
+            'password': 'myprecious'
+        }})
+
+        token = str(resp.json['user']['token'])
+        for _ in range(2):
+            testapp.post_json(url_for('articles.make_article'), {
+                "article": {
+                    "title": "How to train your dragon {}".format(_),
+                    "description": "Ever wonder how?",
+                    "body": "You have to believe",
+                    "tagList": ["reactjs", "angularjs", "dragons"]
+                }
+            }, headers={
+                'Authorization': 'Token {}'.format(token)
+            })
+
+        resp = testapp.get(url_for('articles.get_articles', author=user.username))
+        assert len(resp.json['articles']) == 2
+
+    def test_make_article(self, testapp, user):
+        user = user.get()
+        resp = testapp.post_json(url_for('user.login_user'), {'user': {
+            'email': user.email,
+            'password': 'myprecious'
+        }})
+
+        token = str(resp.json['user']['token'])
+        resp = testapp.post_json(url_for('articles.make_article'), {
+            "article": {
+                "title": "How to train your dragon",
+                "description": "Ever wonder how?",
+                "body": "You have to believe",
+                "tagList": ["reactjs", "angularjs", "dragons"]
+            }
+        }, headers={
+            'Authorization': 'Token {}'.format(token)
+        })
+        assert resp.json['article']['author']['email'] == user.email
+        assert resp.json['article']['body'] == 'You have to believe'
+
+    def test_make_comment_correct_schema(self, testapp, user):
+        from conduit.profile.serializers import profile_schema
+        user = user.get()
+        resp = testapp.post_json(url_for('user.login_user'), {'user': {
+            'email': user.email,
+            'password': 'myprecious'
+        }})
+
+        token = str(resp.json['user']['token'])
+        resp = testapp.post_json(url_for('articles.make_article'), {
+            "article": {
+                "title": "How to train your dragon",
+                "description": "Ever wonder how?",
+                "body": "You have to believe",
+                "tagList": ["reactjs", "angularjs", "dragons"]
+            }
+        }, headers={
+            'Authorization': 'Token {}'.format(token)
+        })
+        slug = resp.json['article']['slug']
+        # make a comment
+        resp = testapp.post_json(url_for('articles.make_comment_on_article', slug=slug), {
+            "comment": {
+                "createdAt": datetime.now().isoformat(),
+                "body": "You have to believe",
+            }
+        }, headers={
+            'Authorization': 'Token {}'.format(token)
+        })
+
+        # check
+        authorp = resp.json['comment']['author']
+        del authorp['following']
+        # assert profile_schema.dump(user).data['profile'] == authorp
+        assert profile_schema.dump(user)['profile'] == authorp
diff --git a/tests/test_authentication.py b/tests/test_authentication.py
new file mode 100644
index 0000000..2f9a2e8
--- /dev/null
+++ b/tests/test_authentication.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+
+from flask import url_for
+from conduit.exceptions import USER_ALREADY_REGISTERED
+
+
+def _register_user(testapp, name, **kwargs):
+    return testapp.post_json(url_for("user.register_user"), {
+        "user": {
+            "username": "mo" + name,
+            "email": "mo" + name + "@mo.mo",
+            "password": "momo"
+        }
+    }, **kwargs)
+
+
+class TestAuthenticate:
+
+    def test_register_user(self, testapp):
+        resp = _register_user(testapp, 'register_user')
+        assert resp.json['user']['email'] == 'moregister_user@mo.mo'
+        assert resp.json['user']['token'] != 'None'
+        assert resp.json['user']['token'] != ''
+
+    def test_user_login(self, testapp):
+        _register_user(testapp, 'login')
+
+        resp = testapp.post_json(url_for('user.login_user'), {'user': {
+            'email': 'mologin@mo.mo',
+            'password': 'momo'
+        }})
+
+        assert resp.json['user']['email'] == 'mologin@mo.mo'
+        assert resp.json['user']['token'] != 'None'
+        assert resp.json['user']['token'] != ''
+
+    def test_get_user(self, testapp):
+        resp = _register_user(testapp, 'getUser')
+        token = str(resp.json['user']['token'])
+        resp = testapp.get(url_for('user.get_user'), headers={
+            'Authorization': 'Token {}'.format(token)
+        })
+        assert resp.json['user']['email'] == 'mogetUser@mo.mo'
+        assert resp.json['user']['token'] == token
+
+    def test_register_already_registered_user(self, testapp):
+        _register_user(testapp, 'already_register')
+        resp = _register_user(testapp, 'already_register', expect_errors=True)
+        assert resp.status_int == 422
+        assert resp.json == USER_ALREADY_REGISTERED['message']
+
+    def test_update_user(self, testapp):
+        resp = _register_user(testapp, 'update')
+        token = str(resp.json['user']['token'])
+        resp = testapp.put_json(url_for('user.update_user'), {
+            'user': {
+                'email': 'meh@mo.mo',
+                'bio': 'I\'m a simple man',
+                'password': 'hmm'
+            }
+        }, headers={
+            'Authorization': 'Token {}'.format(token)
+        })
+        assert resp.json['user']['bio'] == 'I\'m a simple man'
+        assert resp.json['user']['email'] == 'meh@mo.mo'
diff --git a/tests/test_config.py b/tests/test_config.py
new file mode 100644
index 0000000..dc92558
--- /dev/null
+++ b/tests/test_config.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+"""Test configs."""
+from conduit.app import create_app
+from conduit.settings import DevConfig, ProdConfig
+
+
+def test_production_config():
+    """Production config."""
+    app = create_app(ProdConfig)
+    assert app.config['ENV'] == 'prod'
+    assert not app.config['DEBUG']
+
+
+def test_dev_config():
+    """Development config."""
+    app = create_app(DevConfig)
+    assert app.config['ENV'] == 'dev'
+    assert app.config['DEBUG']
diff --git a/tests/test_models.py b/tests/test_models.py
new file mode 100644
index 0000000..0db3002
--- /dev/null
+++ b/tests/test_models.py
@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+"""Model unit tests."""
+import datetime as dt
+
+import pytest
+
+from conduit.user.models import User
+from conduit.profile.models import UserProfile
+from conduit.articles.models import Article, Tags, Comment
+
+
+from .factories import UserFactory
+
+
+@pytest.mark.usefixtures('db')
+class TestUser:
+    """User tests."""
+
+    def test_get_by_id(self):
+        """Get user by ID."""
+        user = User('foo', 'foo@bar.com')
+        user.save()
+
+        retrieved = User.get_by_id(user.id)
+        assert retrieved == user
+
+    def test_created_at_defaults_to_datetime(self):
+        """Test creation date."""
+        user = User(username='foo', email='foo@bar.com')
+        user.save()
+        assert bool(user.created_at)
+        assert isinstance(user.created_at, dt.datetime)
+
+    def test_password_is_nullable(self):
+        """Test null password."""
+        user = User(username='foo', email='foo@bar.com')
+        user.save()
+        assert user.password is None
+
+    def test_factory(self, db):
+        """Test user factory."""
+        user = UserFactory(password='myprecious')
+        db.session.commit()
+        assert bool(user.username)
+        assert bool(user.email)
+        assert bool(user.created_at)
+        assert user.check_password('myprecious')
+
+    def test_check_password(self):
+        """Check password."""
+        user = User.create(username='foo', email='foo@bar.com',
+                           password='foobarbaz123')
+        assert user.check_password('foobarbaz123')
+        assert not user.check_password('barfoobaz')
+
+
+@pytest.mark.usefixtures('db')
+class TestProfile:
+
+    def test_follow_user(self):
+        u1 = User('foo', 'foo@bar.com')
+        u1.save()
+        u2 = User('foo1', 'foo1@bar.com')
+        u2.save()
+        p1 = UserProfile(u1)
+        p2 = UserProfile(u2)
+        p1.save()
+        p2.save()
+        p1.follow(p2)
+        assert p1.is_following(p2)
+
+    def test_unfollow_user(self):
+        u1 = User('foo', 'foo@bar.com')
+        u1.save()
+        u2 = User('foo1', 'foo1@bar.com')
+        u2.save()
+        p1 = UserProfile(u1)
+        p2 = UserProfile(u2)
+        p1.save()
+        p2.save()
+        p1.follow(p2)
+        assert p1.is_following(p2)
+        p1.unfollow(p2)
+        assert not p1.is_following(p2)
+
+    def test_follow_self(self):
+        u1 = User('foo', 'foo@bar.com')
+        u1.save()
+        p1 = UserProfile(u1)
+        p1.save()
+        assert not p1.follow(p1)
+
+    def test_unfollow_self(self):
+        u1 = User('foo', 'foo@bar.com')
+        u1.save()
+        p1 = UserProfile(u1)
+        assert not p1.unfollow(p1)
+
+
+@pytest.mark.usefixtures('db')
+class TestArticles:
+    def test_create_article(self, user):
+        u1 = user.get()
+        article = Article(u1.profile, 'title', 'some body', description='some')
+        article.save()
+        assert article.author.user == u1
+
+    def test_favorite_an_article(self):
+        u1 = User('foo', 'foo@bar.com')
+        u1.save()
+        p1 = UserProfile(u1)
+        p1.save()
+        article = Article(p1, 'title', 'some body', description='some')
+        article.save()
+        assert article.favourite(u1.profile)
+        assert article.is_favourite(u1.profile)
+
+    def test_unfavorite_an_article(self):
+        u1 = User('foo', 'foo@bar.com')
+        u1.save()
+        p1 = UserProfile(u1)
+        p1.save()
+
+        u2 = User('foo1', 'fo1o@bar.com')
+        u2.save()
+        p2 = UserProfile(u2)
+        p2.save()
+
+        article = Article(p1, 'title', 'some body', description='some')
+        article.save()
+        assert article.favourite(p1)
+        assert article.unfavourite(p1)
+        assert not article.is_favourite(p1)
+
+    def test_add_tag(self, user):
+        user = user.get()
+        article = Article(user.profile, 'title', 'some body', description='some')
+        article.save()
+        t = Tags(tagname='python')
+        t1 = Tags(tagname='flask')
+        assert article.add_tag(t)
+        assert article.add_tag(t1)
+        assert len(article.tagList) == 2
+
+    def test_remove_tag(self, user):
+        user = user.get()
+        article = Article(user.profile, 'title', 'some body', description='some')
+        article.save()
+        t1 = Tags(tagname='flask')
+        assert article.add_tag(t1)
+        assert article.remove_tag(t1)
+        assert len(article.tagList) == 0
+
+
+@pytest.mark.usefixtures('db')
+class TestComment:
+
+    def test_make_comment(self, user):
+        user = user.get()
+        article = Article(user.profile, 'title', 'some body', description='some')
+        article.save()
+        comment = Comment(article, user.profile, 'some body')
+        comment.save()
+
+        assert comment.article == article
+        assert comment.author == user.profile
+
+    def test_make_comments(self, user):
+        user = user.get()
+        article = Article(user.profile, 'title', 'some body', description='some')
+        article.save()
+        comment = Comment(article, user.profile, 'some body')
+        comment1 = Comment(article, user.profile, 'some body2')
+        comment.save()
+        comment1.save()
+
+        assert comment.article == article
+        assert comment.author == user.profile
+        assert comment1.article == article
+        assert comment1.author == user.profile
+        assert len(article.comments.all()) == 2
diff --git a/tests/test_profile.py b/tests/test_profile.py
new file mode 100644
index 0000000..62148e5
--- /dev/null
+++ b/tests/test_profile.py
@@ -0,0 +1,45 @@
+# coding: utf-8
+
+from flask import url_for
+from conduit.exceptions import USER_NOT_FOUND
+
+
+def _register_user(testapp, name, **kwargs):
+    return testapp.post_json(url_for('user.register_user'), {
+          "user": {
+              "email": 'foo' + name + '@bar.com',
+              "username": name + 'foobar',
+              "password": 'myprecious'
+          }}, **kwargs)
+
+
+class TestProfile:
+
+    def test_get_profile_not_loggedin(self, testapp):
+        _register_user(testapp, 'not_loggedin')
+        resp = testapp.get(url_for('profiles.get_profile', username='not_loggedinfoobar'))
+        assert resp.json['profile']['email'] == 'foonot_loggedin@bar.com'
+        assert not resp.json['profile']['following']
+
+    def test_get_profile_not_existing(self, testapp):
+        resp = testapp.get(url_for('profiles.get_profile', username='unknownfoobar'), expect_errors=True)
+        assert resp.status_int == 404
+        assert resp.json == USER_NOT_FOUND['message']
+
+    def test_follow_user(self, testapp, user):
+        user = user.get()
+        resp = _register_user(testapp, 'folow_user')
+        token = str(resp.json['user']['token'])
+        resp = testapp.post(url_for('profiles.follow_user', username=user.username), headers={
+            'Authorization': 'Token {}'.format(token)
+        })
+        assert resp.json['profile']['following']
+
+    def test_unfollow_user(self, testapp, user):
+        user = user.get()
+        resp = _register_user(testapp, 'unfolow')
+        token = str(resp.json['user']['token'])
+        resp = testapp.delete(url_for('profiles.unfollow_user', username=user.username), headers={
+            'Authorization': 'Token {}'.format(token)
+        })
+        assert not resp.json['profile']['following']