Add basic integration test for the API

We just start PHP server running selfoss and a web server with feeds, and then try to add the feed to selfoss, fetch the contents and then view the fetched items. But this should be good enough smoke test.

Author: jtojnar

.gitignore

@@ -15,3 +15,4 @@ node_modules
 .env
 vendor/
 .php_cs.cache
+__pycache__

.travis.yml

@@ -32,6 +32,9 @@ cache:
 
 before_install:
     - nvm install 12
+    - pyenv install 3.6.3
+    - pyenv global 3.6.3
+    - pip3 install requests bcrypt
     - if [ -n "$GH_TOKEN" ]; then composer config github-oauth.github.com ${GH_TOKEN}; fi
     - composer self-update
 
@@ -44,6 +47,7 @@ script:
     - npm run lint:server
     - if [ "$CS_FIXER" = true ]; then npm run cs:server; fi
     - npm run test:server
+    - npm run test:integration
 
 before_deploy:
     - git config --global user.email 'Travis CI'

package.json

@@ -27,6 +27,7 @@
     "lint:client": "npm run --prefix assets/ lint",
     "lint:server": "composer run-script lint",
     "test:server": "composer run-script test",
+    "test:integration": "python3 tests/integration/run.py",
     "postinstall": "npm run install-dependencies"
   }
 }

tests/integration/helpers/data_server.py

@@ -0,0 +1,40 @@
+import sys
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from .feeds.fibonacci import numbers_feed
+
+
+FIBONACCI_FEED_LENGTH = 20
+
+
+class DataServer(BaseHTTPRequestHandler):
+    '''
+    A web server returning various feeds for selfoss to fetch.
+    '''
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header('Content-type', 'application/rss+xml')
+        self.end_headers()
+        # Currently, it will only send a feed listing first few fibonacci numbers.
+        self.wfile.write(numbers_feed(FIBONACCI_FEED_LENGTH).encode('utf-8'))
+
+
+class DataServerThread(threading.Thread):
+    '''
+    A thread that starts and stops `DataServer`.
+    '''
+    def __init__(self, host_name='localhost', port=8000):
+        super().__init__()
+        self.host_name = host_name
+        self.port = port
+
+    def run(self):
+        with HTTPServer((self.host_name, self.port), DataServer) as self.web_server:
+            print(f'selfoss server started http://{self.host_name}:{self.port}', file=sys.stderr)
+
+            self.web_server.serve_forever()
+
+        print('selfoss server stopped.', file=sys.stderr)
+
+    def stop(self):
+        self.web_server.shutdown()

tests/integration/helpers/feeds/fibonacci.py

@@ -0,0 +1,53 @@
+import datetime
+from xml.dom import getDOMImplementation
+
+
+def numbers(n: int):
+    '''
+    Generates first *n* fibonacci numbers.
+    '''
+    numbers = []
+    a = 1
+    b = 2
+    for i in range(n):
+        numbers.append((i, a))
+        a, b = b, a + b
+        yield i, a
+
+
+def numbers_feed(n: int) -> str:
+    '''
+    Generates a RSS feed containing first *n* fibonacci numbers.
+    '''
+    doc = getDOMImplementation().createDocument(None, 'rss', None)
+    root = doc.documentElement
+    root.setAttribute('version', '2.0')
+
+    channel = doc.createElement('channel')
+    root.appendChild(channel)
+
+    title = doc.createElement('title')
+    channel.appendChild(title)
+    title.appendChild(doc.createTextNode(f'{n} numbers'))
+
+    od = datetime.datetime.now() - datetime.timedelta(minutes=n)
+
+    for (k, a) in reversed(list(numbers(n))):
+        item = doc.createElement('item')
+        channel.appendChild(item)
+
+        item_title = doc.createElement('title')
+        item.appendChild(item_title)
+        item_title.appendChild(doc.createTextNode(f'{a}'))
+
+        item_guid = doc.createElement('guid')
+        item.appendChild(item_guid)
+        item_guid.setAttribute('isPermaLink', 'true')
+        item_guid.appendChild(doc.createTextNode(f'https://en.wikipedia.org/wiki/{a}'))
+
+        d = od + datetime.timedelta(minutes=k)
+        item_pubdate = doc.createElement('pubDate')
+        item.appendChild(item_pubdate)
+        item_pubdate.appendChild(doc.createTextNode(d.strftime('%a, %d %b %Y %H:%M:%S %z')))
+
+    return doc.toprettyxml(indent=' '*4)

tests/integration/helpers/integration.py

@@ -0,0 +1,46 @@
+import time
+import unittest
+from pathlib import Path
+from .data_server import DataServerThread
+from .selfoss_server import SelfossServerThread
+
+
+class SelfossIntegration(unittest.TestCase):
+    '''
+    Base class for selfoss integration tests.
+    It starts selfoss server and a server providing test feeds.
+    '''
+    def setUp(self):
+        current_dir = Path(__file__).parent.absolute()
+
+        self.data_host_name = 'localhost'
+        self.data_port = 8080
+        self.selfoss_host_name = 'localhost'
+        self.selfoss_port = 8081
+        self.selfoss_username = 'admin'
+        self.selfoss_password = 'hunter2'
+
+        self.selfoss_root = current_dir.parent.parent.parent
+
+        self.selfoss_thread = SelfossServerThread(
+            selfoss_root=self.selfoss_root,
+            password=self.selfoss_password,
+            username=self.selfoss_username,
+            host_name=self.selfoss_host_name,
+            port=self.selfoss_port,
+        )
+        self.selfoss_thread.start()
+
+        self.data_server_thread = DataServerThread(
+            host_name=self.data_host_name,
+            port=self.data_port,
+        )
+        self.data_server_thread.start()
+
+        # Wait for the servers to become properly initialized.
+        time.sleep(2)
+
+    def tearDown(self):
+        self.selfoss_thread.stop()
+        self.data_server_thread.stop()
+

tests/integration/helpers/selfoss_api.py

@@ -0,0 +1,56 @@
+import requests
+
+
+class SelfossApi:
+    def __init__(self, base_uri: str):
+        self.base_uri = base_uri
+        # We still use cookies for authentication so let’s persist them across requests.
+        self.session = requests.Session()
+
+    def login(self, username, password):
+        r = self.session.post(
+            f'{self.base_uri}/login',
+            data={
+                'username': username,
+                'password': password,
+            },
+        )
+        r.raise_for_status()
+
+        return r.json()
+
+    def logout(self):
+        r = self.session.get(
+            f'{self.base_uri}/logout',
+        )
+        r.raise_for_status()
+
+        return r.json()
+
+    def get_items(self):
+        r = self.session.get(
+            f'{self.base_uri}/items',
+        )
+        r.raise_for_status()
+
+        return r.json()
+
+    def add_source(self, spout: str, **params):
+        r = self.session.post(
+            f'{self.base_uri}/source',
+            data={
+                **params,
+                'spout': spout,
+            },
+        )
+        r.raise_for_status()
+
+        return r.json()
+
+    def refresh_all(self):
+        r = self.session.get(
+            f'{self.base_uri}/update',
+        )
+        r.raise_for_status()
+
+        return r.text

tests/integration/helpers/selfoss_server.py

@@ -0,0 +1,64 @@
+import bcrypt
+import os
+import subprocess
+import tempfile
+import threading
+from pathlib import Path
+
+
+class SelfossServerThread(threading.Thread):
+    '''
+    A thread that starts and stops PHP’s built-in web server running selfoss.
+    '''
+    def __init__(self, selfoss_root: Path, username: str, password: str, host_name: str, port: int):
+        super().__init__()
+        self.selfoss_root = selfoss_root
+        self.username = username
+        self.password = password
+        self.host_name = host_name
+        self.port = port
+
+    def run(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Set up data directories.
+            temp_dir = Path(temp_dir)
+            data_dir = temp_dir / 'data'
+            (data_dir / 'sqlite').mkdir(parents=True)
+            (data_dir / 'thumbnails').mkdir(parents=True)
+            (data_dir / 'favicons').mkdir(parents=True)
+
+            # Configure selfoss using environment variables for convenience.
+            test_env = {
+                **os.environ,
+                'SELFOSS_DATADIR': data_dir,
+                'SELFOSS_LOGGER_DESTINATION': 'error_log',
+                'SELFOSS_USERNAME': self.username,
+                'SELFOSS_PASSWORD': bcrypt.hashpw(self.password.encode('utf-8'), bcrypt.gensalt()),
+                'SELFOSS_DB_TYPE': 'sqlite',
+                'SELFOSS_PUBLIC': '1',
+                'SELFOSS_LOGGER_LEVEL': 'DEBUG',
+            }
+
+            current_dir = Path(__file__).parent.absolute()
+
+            php_command = [
+                'php',
+                # We need to enable reading environment variables.
+                '-d', 'variables_order=EGPCS',
+                '-S', f'{self.host_name}:{self.port}',
+                '-c', current_dir / 'php.ini',
+                self.selfoss_root / 'run.php',
+            ]
+
+            # Create the subprocess.
+            self.proc = subprocess.Popen(
+                php_command,
+                env=test_env,
+                cwd=self.selfoss_root,
+            )
+
+            # Wait for it to finish.
+            self.proc.communicate()
+
+    def stop(self):
+        self.proc.kill()

tests/integration/php.ini

@@ -0,0 +1,4 @@
+display_errors = on
+display_startup_errors = on
+error_reporting = E_ALL
+log_errors = on

tests/integration/run.py

@@ -0,0 +1,38 @@
+import requests
+import unittest
+from helpers.data_server import FIBONACCI_FEED_LENGTH
+from helpers.integration import SelfossIntegration
+from helpers.selfoss_api import SelfossApi
+
+
+class BasicWorkflowTest(SelfossIntegration):
+    def test_basic_workflow(self):
+        selfoss_base_uri = f'http://{self.selfoss_host_name}:{self.selfoss_port}'
+        selfoss_api = SelfossApi(selfoss_base_uri)
+
+        items = selfoss_api.get_items()
+        assert len(items) == 0, 'New selfoss instance should have no items.'
+
+        fibonacci_feed_uri = f'http://{self.data_host_name}:{self.data_port}/fibonacci.xml'
+
+        try:
+            add_feed = selfoss_api.add_source('spouts\\rss\\feed', url=fibonacci_feed_uri)
+            assert 'Adding source is privileged operation and should fail without login.'
+        except requests.exceptions.HTTPError as e:
+            assert e.response.status_code == 403, 'Adding source should require authentication.'
+
+        login = selfoss_api.login(self.selfoss_username, self.selfoss_password)
+        assert login['success'], f'Authentication should succeed but it failed with {login["error"]}.'
+
+        add_feed = selfoss_api.add_source('spouts\\rss\\feed', url=fibonacci_feed_uri)
+        assert add_feed['success'], 'Adding source should succeed.'
+        assert add_feed['title'] == '20 numbers', 'Source should auto-detect feed title.'
+
+        refresh = selfoss_api.refresh_all()
+        assert refresh == 'finished', 'Refreshing sources should succeed.'
+
+        items = selfoss_api.get_items()
+        assert len(items) == FIBONACCI_FEED_LENGTH, 'After updating sources, there should be all items from the sources.'
+
+if __name__ == '__main__':
+    unittest.main()