diff --git a/bookmarks/templatetags/bookmarks.py b/bookmarks/templatetags/bookmarks.py
index b5dc3c6..793c520 100644
--- a/bookmarks/templatetags/bookmarks.py
+++ b/bookmarks/templatetags/bookmarks.py
@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Set
from django import template
from django.core.paginator import Page
@@ -26,14 +26,9 @@ class TagGroup:
self.char = char
-def create_tag_groups(tags: List[Tag]):
- # Only display each tag name once, ignoring casing
- # This covers cases where the tag cloud contains shared tags with duplicate names
- # Also means that the cloud can not make assumptions that it will necessarily contain
- # all tags of the current user
- unique_tags = unique(tags, key=lambda x: str.lower(x.name))
+def create_tag_groups(tags: Set[Tag]):
# Ensure groups, as well as tags within groups, are ordered alphabetically
- sorted_tags = sorted(unique_tags, key=lambda x: str.lower(x.name))
+ sorted_tags = sorted(tags, key=lambda x: str.lower(x.name))
group = None
groups = []
@@ -51,10 +46,21 @@ def create_tag_groups(tags: List[Tag]):
@register.inclusion_tag('bookmarks/tag_cloud.html', name='tag_cloud', takes_context=True)
-def tag_cloud(context, tags: List[Tag]):
- groups = create_tag_groups(tags)
+def tag_cloud(context, tags: List[Tag], selected_tags: List[Tag]):
+ # Only display each tag name once, ignoring casing
+ # This covers cases where the tag cloud contains shared tags with duplicate names
+ # Also means that the cloud can not make assumptions that it will necessarily contain
+ # all tags of the current user
+ unique_tags = unique(tags, key=lambda x: str.lower(x.name))
+ unique_selected_tags = unique(selected_tags, key=lambda x: str.lower(x.name))
+
+ has_selected_tags = len(unique_selected_tags) > 0
+ unselected_tags = set(unique_tags).symmetric_difference(unique_selected_tags)
+ groups = create_tag_groups(unselected_tags)
return {
'groups': groups,
+ 'selected_tags': unique_selected_tags,
+ 'has_selected_tags': has_selected_tags,
}
diff --git a/bookmarks/templatetags/shared.py b/bookmarks/templatetags/shared.py
index 65aea28..9e136db 100644
--- a/bookmarks/templatetags/shared.py
+++ b/bookmarks/templatetags/shared.py
@@ -17,7 +17,7 @@ def update_query_string(context, **kwargs):
@register.simple_tag(takes_context=True)
-def append_query_param(context, **kwargs):
+def append_to_query_param(context, **kwargs):
query = context.request.GET.copy()
# Append to or create query param
@@ -32,6 +32,22 @@ def append_query_param(context, **kwargs):
return query.urlencode()
+@register.simple_tag(takes_context=True)
+def remove_from_query_param(context, **kwargs):
+ query = context.request.GET.copy()
+
+ # Remove item from query param
+ for key in kwargs:
+ if query.__contains__(key):
+ value = query.__getitem__(key)
+ parts = value.split()
+ part_to_remove = kwargs[key]
+ updated_parts = [part for part in parts if str.lower(part) != str.lower(part_to_remove)]
+ updated_value = ' '.join(updated_parts)
+ query.__setitem__(key, updated_value)
+
+ return query.urlencode()
+
@register.simple_tag(takes_context=True)
def replace_query_param(context, **kwargs):
query = context.request.GET.copy()
diff --git a/bookmarks/tests/helpers.py b/bookmarks/tests/helpers.py
index 058c2fc..ef57ed1 100644
--- a/bookmarks/tests/helpers.py
+++ b/bookmarks/tests/helpers.py
@@ -2,6 +2,7 @@ import random
import logging
from typing import List
+from bs4 import BeautifulSoup
from django.contrib.auth.models import User
from django.utils import timezone
from django.utils.crypto import get_random_string
@@ -80,6 +81,11 @@ class BookmarkFactoryMixin:
return user
+class HtmlTestMixin:
+ def make_soup(self, html: str):
+ return BeautifulSoup(html, features="html.parser")
+
+
class LinkdingApiTestCase(APITestCase):
def get(self, url, expected_status_code=status.HTTP_200_OK):
response = self.client.get(url)
diff --git a/bookmarks/tests/test_bookmark_archived_view.py b/bookmarks/tests/test_bookmark_archived_view.py
index 12ff174..6c02f63 100644
--- a/bookmarks/tests/test_bookmark_archived_view.py
+++ b/bookmarks/tests/test_bookmark_archived_view.py
@@ -1,18 +1,20 @@
+from typing import List
+
from django.contrib.auth.models import User
from django.test import TestCase
from django.urls import reverse
from bookmarks.models import Bookmark, Tag, UserProfile
-from bookmarks.tests.helpers import BookmarkFactoryMixin
+from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
-class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
+class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
def setUp(self) -> None:
user = self.get_or_create_test_user()
self.client.force_login(user)
- def assertVisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+ def assertVisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
html = response.content.decode()
self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
@@ -22,7 +24,7 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
html
)
- def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+ def assertInvisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
html = response.content.decode()
for bookmark in bookmarks:
@@ -32,16 +34,27 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
count=0
)
- def assertVisibleTags(self, response, tags: [Tag]):
+ def assertVisibleTags(self, response, tags: List[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]):
+ def assertInvisibleTags(self, response, tags: List[Tag]):
for tag in tags:
self.assertNotContains(response, tag.name)
+ def assertSelectedTags(self, response, tags: List[Tag]):
+ soup = self.make_soup(response.content.decode())
+ selected_tags = soup.select('p.selected-tags')[0]
+ self.assertIsNotNone(selected_tags)
+
+ tag_list = selected_tags.select('a')
+ self.assertEqual(len(tag_list), len(tags))
+
+ for tag in tags:
+ self.assertTrue(tag.name in selected_tags.text, msg=f'Selected tags do not contain: {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 = [
@@ -119,7 +132,7 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
self.setup_tag(),
]
- self.setup_bookmark(is_archived=True, tags=[visible_tags[0]], title='searchvalue'),
+ 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]])
@@ -131,6 +144,20 @@ class BookmarkArchivedViewTestCase(TestCase, BookmarkFactoryMixin):
self.assertVisibleTags(response, visible_tags)
self.assertInvisibleTags(response, invisible_tags)
+ def test_should_display_selected_tags_from_query(self):
+ tags = [
+ self.setup_tag(),
+ self.setup_tag(),
+ self.setup_tag(),
+ self.setup_tag(),
+ self.setup_tag(),
+ ]
+ self.setup_bookmark(is_archived=True, tags=tags)
+
+ response = self.client.get(reverse('bookmarks:archived') + f'?q=%23{tags[0].name}+%23{tags[1].name}')
+
+ self.assertSelectedTags(response, [tags[0], tags[1]])
+
def test_should_open_bookmarks_in_new_page_by_default(self):
visible_bookmarks = [
self.setup_bookmark(is_archived=True),
diff --git a/bookmarks/tests/test_bookmark_index_view.py b/bookmarks/tests/test_bookmark_index_view.py
index b07bf4f..c5cb916 100644
--- a/bookmarks/tests/test_bookmark_index_view.py
+++ b/bookmarks/tests/test_bookmark_index_view.py
@@ -1,3 +1,4 @@
+from typing import List
import urllib.parse
from django.contrib.auth.models import User
@@ -5,16 +6,16 @@ from django.test import TestCase
from django.urls import reverse
from bookmarks.models import Bookmark, Tag, UserProfile
-from bookmarks.tests.helpers import BookmarkFactoryMixin
+from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
-class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
+class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
def setUp(self) -> None:
user = self.get_or_create_test_user()
self.client.force_login(user)
- def assertVisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+ def assertVisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
html = response.content.decode()
self.assertContains(response, 'data-is-bookmark-item', count=len(bookmarks))
@@ -24,7 +25,7 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
html
)
- def assertInvisibleBookmarks(self, response, bookmarks: [Bookmark], link_target: str = '_blank'):
+ def assertInvisibleBookmarks(self, response, bookmarks: List[Bookmark], link_target: str = '_blank'):
html = response.content.decode()
for bookmark in bookmarks:
@@ -34,16 +35,27 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
count=0
)
- def assertVisibleTags(self, response, tags: [Tag]):
+ def assertVisibleTags(self, response, tags: List[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]):
+ def assertInvisibleTags(self, response, tags: List[Tag]):
for tag in tags:
self.assertNotContains(response, tag.name)
+ def assertSelectedTags(self, response, tags: List[Tag]):
+ soup = self.make_soup(response.content.decode())
+ selected_tags = soup.select('p.selected-tags')[0]
+ self.assertIsNotNone(selected_tags)
+
+ tag_list = selected_tags.select('a')
+ self.assertEqual(len(tag_list), len(tags))
+
+ for tag in tags:
+ self.assertTrue(tag.name in selected_tags.text, msg=f'Selected tags do not contain: {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 = [
@@ -121,7 +133,7 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
self.setup_tag(),
]
- self.setup_bookmark(tags=[visible_tags[0]], title='searchvalue'),
+ 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]])
@@ -133,6 +145,20 @@ class BookmarkIndexViewTestCase(TestCase, BookmarkFactoryMixin):
self.assertVisibleTags(response, visible_tags)
self.assertInvisibleTags(response, invisible_tags)
+ def test_should_display_selected_tags_from_query(self):
+ tags = [
+ self.setup_tag(),
+ self.setup_tag(),
+ self.setup_tag(),
+ self.setup_tag(),
+ self.setup_tag(),
+ ]
+ self.setup_bookmark(tags=tags)
+
+ response = self.client.get(reverse('bookmarks:index') + f'?q=%23{tags[0].name}+%23{tags[1].name}')
+
+ self.assertSelectedTags(response, [tags[0], tags[1]])
+
def test_should_open_bookmarks_in_new_page_by_default(self):
visible_bookmarks = [
self.setup_bookmark(),
diff --git a/bookmarks/tests/test_tag_cloud_tag.py b/bookmarks/tests/test_tag_cloud_tag.py
index 25b8014..a0133c9 100644
--- a/bookmarks/tests/test_tag_cloud_tag.py
+++ b/bookmarks/tests/test_tag_cloud_tag.py
@@ -1,27 +1,27 @@
from typing import List
-from bs4 import BeautifulSoup
from django.template import Template, RequestContext
from django.test import TestCase, RequestFactory
-from bookmarks.models import Tag, User
-from bookmarks.tests.helpers import BookmarkFactoryMixin
+from bookmarks.models import Tag
+from bookmarks.tests.helpers import BookmarkFactoryMixin, HtmlTestMixin
-class TagCloudTagTest(TestCase, BookmarkFactoryMixin):
- def make_soup(self, html: str):
- return BeautifulSoup(html, features="html.parser")
+class TagCloudTagTest(TestCase, BookmarkFactoryMixin, HtmlTestMixin):
+ def render_template(self, tags: List[Tag], selected_tags: List[Tag] = None, url: str = '/test'):
+ if not selected_tags:
+ selected_tags = []
- def render_template(self, tags: List[Tag], url: str = '/test'):
rf = RequestFactory()
request = rf.get(url)
context = RequestContext(request, {
'request': request,
'tags': tags,
+ 'selected_tags': selected_tags,
})
template_to_render = Template(
'{% load bookmarks %}'
- '{% tag_cloud tags %}'
+ '{% tag_cloud tags selected_tags %}'
)
return template_to_render.render(context)
@@ -41,6 +41,11 @@ class TagCloudTagTest(TestCase, BookmarkFactoryMixin):
link_element = link_elements[tag_index]
self.assertEqual(link_element.text.strip(), tag)
+ def assertNumSelectedTags(self, rendered_template: str, count: int):
+ soup = self.make_soup(rendered_template)
+ link_elements = soup.select('p.selected-tags a')
+ self.assertEqual(len(link_elements), count)
+
def test_group_alphabetically(self):
tags = [
self.setup_tag(name='Cockatoo'),
@@ -75,14 +80,10 @@ class TagCloudTagTest(TestCase, BookmarkFactoryMixin):
])
def test_no_duplicate_tag_names(self):
- user1 = User.objects.create_user('user1', 'user1@example.com', 'password123')
- user2 = User.objects.create_user('user2', 'user2@example.com', 'password123')
- user3 = User.objects.create_user('user3', 'user3@example.com', 'password123')
-
tags = [
- self.setup_tag(name='shared', user=user1),
- self.setup_tag(name='shared', user=user2),
- self.setup_tag(name='shared', user=user3),
+ self.setup_tag(name='shared', user=self.setup_user()),
+ self.setup_tag(name='shared', user=self.setup_user()),
+ self.setup_tag(name='shared', user=self.setup_user()),
]
rendered_template = self.render_template(tags)
@@ -92,3 +93,88 @@ class TagCloudTagTest(TestCase, BookmarkFactoryMixin):
'shared',
],
])
+
+ def test_selected_tags(self):
+ tags = [
+ self.setup_tag(name='tag1'),
+ self.setup_tag(name='tag2'),
+ ]
+
+ rendered_template = self.render_template(tags, tags, url='/test?q=%23tag1 %23tag2')
+
+ self.assertNumSelectedTags(rendered_template, 2)
+
+ self.assertInHTML('''
+