refacto urls

Author: SamR1

Makefile

@@ -37,9 +37,11 @@ lint-fix:
 	$(BLACK) $(FLASK_APP)
 
 serve:
+	echo 'Running on http://$(HOST):$(PORT)'
 	$(FLASK) run --with-threads -h $(HOST) -p $(PORT)
 
 run:
+	echo 'Running on http://$(HOST):$(PORT)'
 	FLASK_ENV=production && $(GUNICORN) -b 127.0.0.1:5000 "$(FLASK_APP):create_app()" --error-logfile $(GUNICORN_LOG)
 
 venv:

twootfeed/config.py

@@ -1,10 +1,10 @@
 import os
-import secrets
 
 from twootfeed import param
+from twootfeed.tests.data import TEST_TOKEN
 
 if os.getenv('TWOOTFEED_SETTINGS') == 'TestingConfig':
-    param['feed']['token'] = secrets.token_urlsafe()
+    param['feed']['token'] = TEST_TOKEN
 
 
 class BaseConfig:

twootfeed/mastodon/routes.py

@@ -1,46 +1,46 @@
 from typing import Tuple
 
-from flask import Blueprint
+from flask import Blueprint, request
 from twootfeed import mastodon_api, param as mastodon_param
 from twootfeed.mastodon.generate_toots_feed import generate_xml
 from twootfeed.utils.decorator import require_token
 
 mastodon_bp = Blueprint('mastodon', __name__)
 
 
-@mastodon_bp.route('/toots/<hashtag>', methods=['GET'])
+@mastodon_bp.route('/toots/tags/<tag>', methods=['GET'])
 @require_token
-def tootfeed_hashtag(hashtag: str) -> Tuple[str, int]:
+def toots_feed_hashtag(tag: str) -> Tuple[str, int]:
     """generate a rss feed from parsed mastodon search"""
-    return generate_xml(mastodon_api, mastodon_param, {'hashtag': hashtag})
+    return generate_xml(mastodon_api, mastodon_param, {'hashtag': tag})
 
 
-@mastodon_bp.route('/toots/search/<query_feed>', methods=['GET'])
-@mastodon_bp.route('/toot_search/<query_feed>', methods=['GET'])
+@mastodon_bp.route('/toots/search', methods=['GET'])
 @require_token
-def tootfeed(query_feed: str) -> Tuple[str, int]:
+def toots_feed_search() -> Tuple[str, int]:
     """generate a rss feed from parsed mastodon search"""
-    return generate_xml(mastodon_api, mastodon_param, {'query': query_feed})
+    q = request.args.get('q')
+    if not q:
+        return 'missing query', 400
+    return generate_xml(mastodon_api, mastodon_param, {'query': q})
 
 
 @mastodon_bp.route('/toots/favorites', methods=['GET'])
-@mastodon_bp.route('/toot_favorites', methods=['GET'])
 @require_token
-def toot_favorites_feed() -> Tuple[str, int]:
+def toots_favorites_feed() -> Tuple[str, int]:
     """generate a rss feed authenticated user's favorites"""
     return generate_xml(mastodon_api, mastodon_param, target='favorites')
 
 
 @mastodon_bp.route('/toots/bookmarks', methods=['GET'])
-@mastodon_bp.route('/toot_bookmarks', methods=['GET'])
 @require_token
-def toot_bookmarks_feed() -> Tuple[str, int]:
+def toots_bookmarks_feed() -> Tuple[str, int]:
     """generate a rss feed authenticated user's bookmarks"""
     return generate_xml(mastodon_api, mastodon_param, target='bookmarks')
 
 
-@mastodon_bp.route('/home_timeline', methods=['GET'])
+@mastodon_bp.route('/toots/home_timeline', methods=['GET'])
 @require_token
-def home_timeline() -> Tuple[str, int]:
+def toots_home_timeline() -> Tuple[str, int]:
     """generate a rss feed authenticated user's bookmarks"""
     return generate_xml(mastodon_api, mastodon_param, target='home_timeline')

twootfeed/tests/test_mastodon_routes.py

@@ -0,0 +1,92 @@
+from uuid import uuid4
+
+import pytest
+from flask import Flask
+
+from .data import TEST_TOKEN
+from .test_twitter_routes import TestTwitterRoutes
+
+MASTODON_ENDPOINTS = [
+    '/toots/favorites',
+    '/toots/bookmarks',
+    '/toots/home_timeline',
+]
+
+
+class TestMastodonTagsRoute:
+    endpoint = '/toots/tags/{tag}'
+
+    def test_it_returns_401_when_token_is_missing(
+        self, app_missing_token: Flask
+    ) -> None:
+        client = app_missing_token.test_client()
+
+        response = client.get(self.endpoint.format(tag=uuid4().hex))
+
+        assert response.status_code == 401
+        data = response.data.decode()
+        assert data == 'missing token'
+
+    def test_it_returns_403_when_token_is_invalid(
+        self, app_invalid_token: Flask
+    ) -> None:
+        client = app_invalid_token.test_client()
+
+        response = client.get(
+            f'{self.endpoint.format(tag=uuid4().hex)}?token=invalid'
+        )
+
+        assert response.status_code == 403
+        data = response.data.decode()
+        assert data == 'invalid token'
+
+    def test_it_returns_200_when_tag_is_provided(self, app: Flask) -> None:
+        client = app.test_client()
+
+        response = client.get(
+            f'{self.endpoint.format(tag=uuid4().hex)}?&token={TEST_TOKEN}'
+        )
+
+        assert response.status_code == 200
+        data = response.data.decode()
+        assert '<rss version="2.0">' in data
+
+
+class TestMastodonSearchRoute(TestTwitterRoutes):
+    endpoint = '/toots/search'
+
+
+class TestMastodonRoutes:
+    @pytest.mark.parametrize('input_endpoint', MASTODON_ENDPOINTS)
+    def test_it_returns_401_when_token_is_missing(
+        self, app_missing_token: Flask, input_endpoint: str
+    ) -> None:
+        client = app_missing_token.test_client()
+
+        response = client.get(input_endpoint)
+
+        assert response.status_code == 401
+        data = response.data.decode()
+        assert data == 'missing token'
+
+    @pytest.mark.parametrize('input_endpoint', MASTODON_ENDPOINTS)
+    def test_it_returns_403_when_token_is_invalid(
+        self, app_invalid_token: Flask, input_endpoint: str
+    ) -> None:
+        client = app_invalid_token.test_client()
+
+        response = client.get(f'{input_endpoint}?token=invalid')
+
+        assert response.status_code == 403
+        data = response.data.decode()
+        assert data == 'invalid token'
+
+    @pytest.mark.parametrize('input_endpoint', MASTODON_ENDPOINTS)
+    def test_it_returns_200(self, app: Flask, input_endpoint: str) -> None:
+        client = app.test_client()
+
+        response = client.get(f'{input_endpoint}?token={TEST_TOKEN}')
+
+        assert response.status_code == 200
+        data = response.data.decode()
+        assert '<rss version="2.0">' in data

twootfeed/tests/test_routes.py

@@ -0,0 +1,51 @@
+from uuid import uuid4
+
+from flask import Flask
+
+from .data import TEST_TOKEN
+
+
+class TestTwitterRoutes:
+    endpoint = '/tweets'
+
+    def test_it_returns_401_when_token_is_missing(
+        self, app_missing_token: Flask
+    ) -> None:
+        client = app_missing_token.test_client()
+
+        response = client.get(self.endpoint)
+
+        assert response.status_code == 401
+        data = response.data.decode()
+        assert data == 'missing token'
+
+    def test_it_returns_403_when_token_is_invalid(
+        self, app_invalid_token: Flask
+    ) -> None:
+        client = app_invalid_token.test_client()
+
+        response = client.get(f'{self.endpoint}?token=invalid')
+
+        assert response.status_code == 403
+        data = response.data.decode()
+        assert data == 'invalid token'
+
+    def test_it_returns_400_when_query_is_missing(self, app: Flask) -> None:
+        client = app.test_client()
+
+        response = client.get(f'{self.endpoint}?token={TEST_TOKEN}')
+
+        assert response.status_code == 400
+        data = response.data.decode()
+        assert data == 'missing query'
+
+    def test_it_returns_200_when_query_valid(self, app: Flask) -> None:
+        client = app.test_client()
+
+        response = client.get(
+            f'{self.endpoint}?q={uuid4().hex}&token={TEST_TOKEN}'
+        )
+
+        assert response.status_code == 200
+        data = response.data.decode()
+        assert '<rss version="2.0">' in data

twootfeed/tests/test_twitter_routes.py

@@ -1,16 +1,18 @@
 from typing import Tuple
 
-from flask import Blueprint
+from flask import Blueprint, request
 from twootfeed import param, twitter_api
 from twootfeed.twitter.generate_tweets_feed import generate_xml
 from twootfeed.utils.decorator import require_token
 
 twitter_bp = Blueprint('twitter', __name__)
 
 
-@twitter_bp.route('/<query_feed>', methods=['GET'])
-@twitter_bp.route('/tweets/<query_feed>', methods=['GET'])
+@twitter_bp.route('/tweets', methods=['GET'])
 @require_token
-def tweetfeed(query_feed: str) -> Tuple[str, int]:
+def tweetfeed() -> Tuple[str, int]:
     """generate a rss feed from parsed twitter search"""
-    return generate_xml(twitter_api, query_feed, param)
+    q = request.args.get('q')
+    if not q:
+        return 'missing query', 400
+    return generate_xml(twitter_api, q, param)