diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
new file mode 100644
index 0000000..79ee123
--- /dev/null
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>
\ No newline at end of file
diff --git a/bookmarks/templates/bookmarks/bookmark_list.html b/bookmarks/templates/bookmarks/bookmark_list.html
index d42c2e1..d2c2bcb 100644
--- a/bookmarks/templates/bookmarks/bookmark_list.html
+++ b/bookmarks/templates/bookmarks/bookmark_list.html
@@ -3,7 +3,7 @@
 
 <ul class="bookmark-list">
     {% for bookmark in bookmarks %}
-        <li>
+        <li data-is-bookmark-item>
             <label class="form-checkbox bulk-edit-toggle">
                 <input type="checkbox" name="bookmark_id" value="{{ bookmark.id }}">
                 <i class="form-icon"></i>
diff --git a/bookmarks/templates/bookmarks/tag_cloud.html b/bookmarks/templates/bookmarks/tag_cloud.html
index f15d8e2..e48ffe7 100644
--- a/bookmarks/templates/bookmarks/tag_cloud.html
+++ b/bookmarks/templates/bookmarks/tag_cloud.html
@@ -7,13 +7,13 @@
                 {# Highlight first char of first tag in group #}
                 {% if forloop.counter == 1 %}
                     <a href="?{% append_query_param q=tag.name|hash_tag %}"
-                       class="mr-2">
+                       class="mr-2" data-is-tag-item>
                         <span class="highlight-char">{{ tag.name|first_char }}</span><span>{{ tag.name|remaining_chars:1 }}</span>
                     </a>
                 {% else %}
                     {# Render remaining tags normally #}
                     <a href="?{% append_query_param q=tag.name|hash_tag %}"
-                       class="mr-2">
+                       class="mr-2" data-is-tag-item>
                         <span>{{ tag.name }}</span>
                     </a>
                 {% endif %}
diff --git a/bookmarks/tests/helpers.py b/bookmarks/tests/helpers.py
index 412a768..fc36de4 100644
--- a/bookmarks/tests/helpers.py
+++ b/bookmarks/tests/helpers.py
@@ -16,12 +16,21 @@ class BookmarkFactoryMixin:
 
         return self.user
 
-    def setup_bookmark(self, is_archived: bool = False, tags: [Tag] = [], user: User = None):
+    def setup_bookmark(self,
+                       is_archived: bool = False,
+                       tags=None,
+                       user: User = None,
+                       title: str = '',
+                       description: str = ''):
+        if tags is None:
+            tags = []
         if user is None:
             user = self.get_or_create_test_user()
         unique_id = get_random_string(length=32)
         bookmark = Bookmark(
             url='https://example.com/' + unique_id,
+            title=title,
+            description=description,
             date_added=timezone.now(),
             date_modified=timezone.now(),
             owner=user,
diff --git a/bookmarks/tests/test_bookmark_archive_view.py b/bookmarks/tests/test_bookmark_archive_view.py
new file mode 100644
index 0000000..32fa1a0
--- /dev/null
+++ b/bookmarks/tests/test_bookmark_archive_view.py
@@ -0,0 +1,35 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkArchiveViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_archive_bookmark(self):
+        bookmark = self.setup_bookmark()
+
+        self.client.get(reverse('bookmarks:archive', args=[bookmark.id]))
+        bookmark.refresh_from_db()
+
+        self.assertTrue(bookmark.is_archived)
+
+    def test_should_redirect_to_index(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:archive', args=[bookmark.id]))
+
+        self.assertRedirects(response, reverse('bookmarks:index'))
+
+    def test_should_redirect_to_return_url_when_specified(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(
+            reverse('bookmarks:archive', args=[bookmark.id]) + '?return_url=' + reverse('bookmarks:close')
+        )
+
+        self.assertRedirects(response, reverse('bookmarks:close'))
diff --git a/bookmarks/tests/test_bookmark_archived_view.py b/bookmarks/tests/test_bookmark_archived_view.py
new file mode 100644
index 0000000..8920fac
--- /dev/null
+++ b/bookmarks/tests/test_bookmark_archived_view.py
@@ -0,0 +1,132 @@
+from django.contrib.auth.models import User
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import Bookmark, Tag
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def assertVisibleBookmarks(self, response, bookmarks: [Bookmark]):
+        html = response.content.decode()
+        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
+
+        for bookmark in bookmarks:
+            self.assertInHTML(
+                '<a href="{0}" target="_blank" rel="noopener">{1}</a>'.format(bookmark.url, bookmark.resolved_title),
+                html
+            )
+
+    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark]):
+        html = response.content.decode()
+
+        for bookmark in bookmarks:
+            self.assertInHTML(
+                '<a href="{0}" target="_blank" rel="noopener">{1}</a>'.format(bookmark.url, bookmark.resolved_title),
+                html,
+                count=0
+            )
+
+    def assertVisibleTags(self, response, tags: [Tag]):
+        self.assertContains(response, 'data-is-tag-item', count=len(tags))
+
+        for tag in tags:
+            self.assertContains(response, tag.name)
+
+    def assertInvisibleTags(self, response, tags: [Tag]):
+        for tag in tags:
+            self.assertNotContains(response, tag.name)
+
+    def test_should_list_archived_and_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        visible_bookmarks = [
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True)
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(is_archived=False),
+            self.setup_bookmark(is_archived=True, user=other_user),
+        ]
+
+        response = self.client.get(reverse('bookmarks:archived'))
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_bookmarks_matching_query(self):
+        visible_bookmarks = [
+            self.setup_bookmark(is_archived=True, title='searchvalue'),
+            self.setup_bookmark(is_archived=True, title='searchvalue'),
+            self.setup_bookmark(is_archived=True, title='searchvalue')
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(is_archived=True)
+        ]
+
+        response = self.client.get(reverse('bookmarks:archived') + '?q=searchvalue')
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_tags_for_archived_and_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        visible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        invisible_tags = [
+            self.setup_tag(),  # unused tag
+            self.setup_tag(),  # used in archived bookmark
+            self.setup_tag(user=other_user),  # belongs to other user
+        ]
+
+        # Assign tags to some bookmarks with duplicates
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[1]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[1]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[2]])
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[2]])
+
+        self.setup_bookmark(is_archived=False, tags=[invisible_tags[1]])
+        self.setup_bookmark(is_archived=True, tags=[invisible_tags[2]], user=other_user)
+
+        response = self.client.get(reverse('bookmarks:archived'))
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
+
+    def test_should_list_tags_for_bookmarks_matching_query(self):
+        visible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        invisible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[0]], title='searchvalue'),
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[1]], title='searchvalue')
+        self.setup_bookmark(is_archived=True, tags=[visible_tags[2]], title='searchvalue')
+        self.setup_bookmark(is_archived=True, tags=[invisible_tags[0]])
+        self.setup_bookmark(is_archived=True, tags=[invisible_tags[1]])
+        self.setup_bookmark(is_archived=True, tags=[invisible_tags[2]])
+
+        response = self.client.get(reverse('bookmarks:archived') + '?q=searchvalue')
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
diff --git a/bookmarks/tests/test_bulk_edit_integration.py b/bookmarks/tests/test_bookmark_bulk_edit_view.py
similarity index 98%
rename from bookmarks/tests/test_bulk_edit_integration.py
rename to bookmarks/tests/test_bookmark_bulk_edit_view.py
index fcac415..0db075a 100644
--- a/bookmarks/tests/test_bulk_edit_integration.py
+++ b/bookmarks/tests/test_bookmark_bulk_edit_view.py
@@ -6,7 +6,7 @@ from bookmarks.models import Bookmark
 from bookmarks.tests.helpers import BookmarkFactoryMixin
 
 
-class BulkEditIntegrationTests(TestCase, BookmarkFactoryMixin):
+class BookmarkBulkEditViewTestCase(TestCase, BookmarkFactoryMixin):
 
     def setUp(self) -> None:
         user = self.get_or_create_test_user()
diff --git a/bookmarks/tests/test_bookmark_edit_view.py b/bookmarks/tests/test_bookmark_edit_view.py
new file mode 100644
index 0000000..2209025
--- /dev/null
+++ b/bookmarks/tests/test_bookmark_edit_view.py
@@ -0,0 +1,97 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import build_tag_string
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkEditViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def create_form_data(self, overrides=None):
+        if overrides is None:
+            overrides = {}
+        form_data = {
+            'url': 'http://example.com/edited',
+            'tag_string': 'editedtag1 editedtag2',
+            'title': 'edited title',
+            'description': 'edited description',
+            'return_url': reverse('bookmarks:index'),
+        }
+        return {**form_data, **overrides}
+
+    def test_should_edit_bookmark(self):
+        bookmark = self.setup_bookmark()
+        form_data = self.create_form_data({'id': bookmark.id})
+
+        self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
+
+        bookmark.refresh_from_db()
+
+        self.assertEqual(bookmark.owner, self.user)
+        self.assertEqual(bookmark.url, form_data['url'])
+        self.assertEqual(bookmark.title, form_data['title'])
+        self.assertEqual(bookmark.description, form_data['description'])
+        self.assertEqual(bookmark.tags.count(), 2)
+        self.assertEqual(bookmark.tags.all()[0].name, 'editedtag1')
+        self.assertEqual(bookmark.tags.all()[1].name, 'editedtag2')
+
+    def test_should_use_bookmark_index_as_default_return_url(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<input type="hidden" name="return_url" value="{0}" '
+            'id="id_return_url">'.format(reverse('bookmarks:index')),
+            html)
+
+    def test_should_prefill_bookmark_form_fields(self):
+        tag1 = self.setup_tag()
+        tag2 = self.setup_tag()
+        bookmark = self.setup_bookmark(tags=[tag1, tag2], title='edited title', description='edited description')
+
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]))
+        html = response.content.decode()
+
+        self.assertInHTML('<input type="text" name="url" '
+                          'value="{0}" placeholder=" " '
+                          'autofocus class="form-input" required '
+                          'id="id_url">'.format(bookmark.url),
+                          html)
+
+        tag_string = build_tag_string(bookmark.tag_names, ' ')
+        self.assertInHTML('<input type="text" name="tag_string" '
+                          'value="{0}" autocomplete="off" '
+                          'class="form-input" '
+                          'id="id_tag_string">'.format(tag_string),
+                          html)
+
+        self.assertInHTML('<input type="text" name="title" maxlength="512" '
+                          'autocomplete="off" class="form-input" '
+                          'value="{0}" id="id_title">'.format(bookmark.title),
+                          html)
+
+        self.assertInHTML('<textarea name="description" cols="40" rows="4" class="form-input" id="id_description">{0}'
+                          '</textarea>'.format(bookmark.description),
+                          html)
+
+    def test_should_prefill_return_url_from_url_parameter(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:edit', args=[bookmark.id]) + '?return_url=/test-return-url')
+        html = response.content.decode()
+
+        self.assertInHTML('<input type="hidden" name="return_url" value="/test-return-url" id="id_return_url">', html)
+
+    def test_should_redirect_to_return_url(self):
+        bookmark = self.setup_bookmark()
+        form_data = self.create_form_data({'return_url': reverse('bookmarks:close')})
+
+        response = self.client.post(reverse('bookmarks:edit', args=[bookmark.id]), form_data)
+
+        self.assertRedirects(response, form_data['return_url'])
diff --git a/bookmarks/tests/test_bookmark_index_view.py b/bookmarks/tests/test_bookmark_index_view.py
new file mode 100644
index 0000000..d8a69c6
--- /dev/null
+++ b/bookmarks/tests/test_bookmark_index_view.py
@@ -0,0 +1,132 @@
+from django.contrib.auth.models import User
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import Bookmark, Tag
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def assertVisibleBookmarks(self, response, bookmarks: [Bookmark]):
+        html = response.content.decode()
+        self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
+
+        for bookmark in bookmarks:
+            self.assertInHTML(
+                '<a href="{0}" target="_blank" rel="noopener">{1}</a>'.format(bookmark.url, bookmark.resolved_title),
+                html
+            )
+
+    def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark]):
+        html = response.content.decode()
+
+        for bookmark in bookmarks:
+            self.assertInHTML(
+                '<a href="{0}" target="_blank" rel="noopener">{1}</a>'.format(bookmark.url, bookmark.resolved_title),
+                html,
+                count=0
+            )
+
+    def assertVisibleTags(self, response, tags: [Tag]):
+        self.assertContains(response, 'data-is-tag-item', count=len(tags))
+
+        for tag in tags:
+            self.assertContains(response, tag.name)
+
+    def assertInvisibleTags(self, response, tags: [Tag]):
+        for tag in tags:
+            self.assertNotContains(response, tag.name)
+
+    def test_should_list_unarchived_and_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        visible_bookmarks = [
+            self.setup_bookmark(),
+            self.setup_bookmark(),
+            self.setup_bookmark()
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(is_archived=True),
+            self.setup_bookmark(user=other_user),
+        ]
+
+        response = self.client.get(reverse('bookmarks:index'))
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_bookmarks_matching_query(self):
+        visible_bookmarks = [
+            self.setup_bookmark(title='searchvalue'),
+            self.setup_bookmark(title='searchvalue'),
+            self.setup_bookmark(title='searchvalue')
+        ]
+        invisible_bookmarks = [
+            self.setup_bookmark(),
+            self.setup_bookmark(),
+            self.setup_bookmark()
+        ]
+
+        response = self.client.get(reverse('bookmarks:index') + '?q=searchvalue')
+
+        self.assertContains(response, '<ul class="bookmark-list">')  # Should render list
+        self.assertVisibleBookmarks(response, visible_bookmarks)
+        self.assertInvisibleBookmarks(response, invisible_bookmarks)
+
+    def test_should_list_tags_for_unarchived_and_user_owned_bookmarks(self):
+        other_user = User.objects.create_user('otheruser', 'otheruser@example.com', 'password123')
+        visible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        invisible_tags = [
+            self.setup_tag(),  # unused tag
+            self.setup_tag(),  # used in archived bookmark
+            self.setup_tag(user=other_user),  # belongs to other user
+        ]
+
+        # Assign tags to some bookmarks with duplicates
+        self.setup_bookmark(tags=[visible_tags[0]])
+        self.setup_bookmark(tags=[visible_tags[0]])
+        self.setup_bookmark(tags=[visible_tags[1]])
+        self.setup_bookmark(tags=[visible_tags[1]])
+        self.setup_bookmark(tags=[visible_tags[2]])
+        self.setup_bookmark(tags=[visible_tags[2]])
+
+        self.setup_bookmark(tags=[invisible_tags[1]], is_archived=True)
+        self.setup_bookmark(tags=[invisible_tags[2]], user=other_user)
+
+        response = self.client.get(reverse('bookmarks:index'))
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
+
+    def test_should_list_tags_for_bookmarks_matching_query(self):
+        visible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+        invisible_tags = [
+            self.setup_tag(),
+            self.setup_tag(),
+            self.setup_tag(),
+        ]
+
+        self.setup_bookmark(tags=[visible_tags[0]], title='searchvalue'),
+        self.setup_bookmark(tags=[visible_tags[1]], title='searchvalue')
+        self.setup_bookmark(tags=[visible_tags[2]], title='searchvalue')
+        self.setup_bookmark(tags=[invisible_tags[0]])
+        self.setup_bookmark(tags=[invisible_tags[1]])
+        self.setup_bookmark(tags=[invisible_tags[2]])
+
+        response = self.client.get(reverse('bookmarks:index') + '?q=searchvalue')
+
+        self.assertVisibleTags(response, visible_tags)
+        self.assertInvisibleTags(response, invisible_tags)
diff --git a/bookmarks/tests/test_bookmark_new_view.py b/bookmarks/tests/test_bookmark_new_view.py
new file mode 100644
index 0000000..55489a0
--- /dev/null
+++ b/bookmarks/tests/test_bookmark_new_view.py
@@ -0,0 +1,81 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import Bookmark
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkNewViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def create_form_data(self, overrides=None):
+        if overrides is None:
+            overrides = {}
+        form_data = {
+            'url': 'http://example.com',
+            'tag_string': 'tag1 tag2',
+            'title': 'test title',
+            'description': 'test description',
+            'auto_close': '',
+        }
+        return {**form_data, **overrides}
+
+    def test_should_create_new_bookmark(self):
+        form_data = self.create_form_data()
+
+        self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertEqual(Bookmark.objects.count(), 1)
+
+        bookmark = Bookmark.objects.first()
+        self.assertEqual(bookmark.owner, self.user)
+        self.assertEqual(bookmark.url, form_data['url'])
+        self.assertEqual(bookmark.title, form_data['title'])
+        self.assertEqual(bookmark.description, form_data['description'])
+        self.assertEqual(bookmark.tags.count(), 2)
+        self.assertEqual(bookmark.tags.all()[0].name, 'tag1')
+        self.assertEqual(bookmark.tags.all()[1].name, 'tag2')
+
+    def test_should_prefill_url_from_url_parameter(self):
+        response = self.client.get(reverse('bookmarks:new') + '?url=http://example.com')
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<input type="text" name="url" value="http://example.com" '
+            'placeholder=" " autofocus class="form-input" required '
+            'id="id_url">',
+            html)
+
+    def test_should_enable_auto_close_when_specified_in_url_parameter(self):
+        response = self.client.get(
+            reverse('bookmarks:new') + '?auto_close')
+        html = response.content.decode()
+
+        self.assertInHTML(
+            '<input type="hidden" name="auto_close" value="true" '
+            'id="id_auto_close">',
+            html)
+
+    def test_should_not_enable_auto_close_when_not_specified_in_url_parameter(
+            self):
+        response = self.client.get(reverse('bookmarks:new'))
+        html = response.content.decode()
+
+        self.assertInHTML('<input type="hidden" name="auto_close" id="id_auto_close">',html)
+
+    def test_should_redirect_to_index_view(self):
+        form_data = self.create_form_data()
+
+        response = self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertRedirects(response, reverse('bookmarks:index'))
+
+    def test_auto_close_should_redirect_to_close_view(self):
+        form_data = self.create_form_data({'auto_close': 'true'})
+
+        response = self.client.post(reverse('bookmarks:new'), form_data)
+
+        self.assertRedirects(response, reverse('bookmarks:close'))
diff --git a/bookmarks/tests/test_bookmark_remove_view.py b/bookmarks/tests/test_bookmark_remove_view.py
new file mode 100644
index 0000000..35ce07e
--- /dev/null
+++ b/bookmarks/tests/test_bookmark_remove_view.py
@@ -0,0 +1,35 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.models import Bookmark
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkRemoveViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_delete_bookmark(self):
+        bookmark = self.setup_bookmark()
+
+        self.client.get(reverse('bookmarks:remove', args=[bookmark.id]))
+
+        self.assertEqual(Bookmark.objects.count(), 0)
+
+    def test_should_redirect_to_index(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:remove', args=[bookmark.id]))
+
+        self.assertRedirects(response, reverse('bookmarks:index'))
+
+    def test_should_redirect_to_return_url_when_specified(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(
+            reverse('bookmarks:remove', args=[bookmark.id]) + '?return_url=' + reverse('bookmarks:close')
+        )
+
+        self.assertRedirects(response, reverse('bookmarks:close'))
diff --git a/bookmarks/tests/test_bookmark_unarchive_view.py b/bookmarks/tests/test_bookmark_unarchive_view.py
new file mode 100644
index 0000000..ece6b0c
--- /dev/null
+++ b/bookmarks/tests/test_bookmark_unarchive_view.py
@@ -0,0 +1,35 @@
+from django.test import TestCase
+from django.urls import reverse
+
+from bookmarks.tests.helpers import BookmarkFactoryMixin
+
+
+class BookmarkUnarchiveViewTestCase(TestCase, BookmarkFactoryMixin):
+
+    def setUp(self) -> None:
+        user = self.get_or_create_test_user()
+        self.client.force_login(user)
+
+    def test_should_unarchive_bookmark(self):
+        bookmark = self.setup_bookmark(is_archived=True)
+
+        self.client.get(reverse('bookmarks:unarchive', args=[bookmark.id]))
+        bookmark.refresh_from_db()
+
+        self.assertFalse(bookmark.is_archived)
+
+    def test_should_redirect_to_archive(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(reverse('bookmarks:unarchive', args=[bookmark.id]))
+
+        self.assertRedirects(response, reverse('bookmarks:archived'))
+
+    def test_should_redirect_to_return_url_when_specified(self):
+        bookmark = self.setup_bookmark()
+
+        response = self.client.get(
+            reverse('bookmarks:unarchive', args=[bookmark.id]) + '?return_url=' + reverse('bookmarks:close')
+        )
+
+        self.assertRedirects(response, reverse('bookmarks:close'))
diff --git a/bookmarks/tests/test_bookmarks_list_tag.py b/bookmarks/tests/test_bookmarks_list_tag.py
index f9ba9a3..842d62b 100644
--- a/bookmarks/tests/test_bookmarks_list_tag.py
+++ b/bookmarks/tests/test_bookmarks_list_tag.py
@@ -4,8 +4,8 @@ from django.template import Template, RequestContext
 from django.test import TestCase, RequestFactory
 from django.utils import timezone, formats
 
-from bookmarks.tests.helpers import BookmarkFactoryMixin
 from bookmarks.models import UserProfile
+from bookmarks.tests.helpers import BookmarkFactoryMixin
 
 
 class BookmarkListTagTest(TestCase, BookmarkFactoryMixin):
diff --git a/bookmarks/tests/test_pagination_tag.py b/bookmarks/tests/test_pagination_tag.py
index 84cd070..0eff778 100644
--- a/bookmarks/tests/test_pagination_tag.py
+++ b/bookmarks/tests/test_pagination_tag.py
@@ -1,6 +1,6 @@
 from django.core.paginator import Paginator
-from django.test import SimpleTestCase, RequestFactory
 from django.template import Template, RequestContext
+from django.test import SimpleTestCase, RequestFactory
 
 
 class PaginationTagTest(SimpleTestCase):
diff --git a/bookmarks/tests/test_tags_service.py b/bookmarks/tests/test_tags_service.py
index 5f7a1cd..4cdce10 100644
--- a/bookmarks/tests/test_tags_service.py
+++ b/bookmarks/tests/test_tags_service.py
@@ -1,4 +1,5 @@
 import datetime
+
 from django.contrib.auth import get_user_model
 from django.test import TestCase
 from django.utils import timezone
diff --git a/bookmarks/tests/test_user_profile_model.py b/bookmarks/tests/test_user_profile_model.py
index ce7010e..431eb03 100644
--- a/bookmarks/tests/test_user_profile_model.py
+++ b/bookmarks/tests/test_user_profile_model.py
@@ -1,5 +1,5 @@
-from django.test import TestCase
 from django.contrib.auth.models import User
+from django.test import TestCase
 
 from bookmarks.models import UserProfile