Removed old testing.

release_tests/mtt_tc.py

@@ -1,111 +0,0 @@
-"""Base for MoreThanTest test cases."""
-
-from asyncio import create_subprocess_exec, gather, sleep
-from pathlib import Path
-from socket import socket
-from unittest import IsolatedAsyncioTestCase
-from aiohttp import ClientSession
-
-
-LOCALHOST = "127.0.0.1"
-SESSION_KEY = "sessionid"
-HOST = "example.com"
-
-
-class Server:
-    """Setup and run servers."""
-
-    def __init__(self, *args):
-        """Initialize class"""
-        app = Path.cwd().joinpath("target", "release", "morethantext")
-        addr = "127.0.0.1"
-        port = 3000
-        if args:
-            self.cmd = list(args)
-            self.cmd.insert(0, app)
-            get_port = False
-            get_addr = False
-            for item in args:
-                if get_port:
-                    port = item
-                    get_port = False
-                if get_addr:
-                    addr = item
-                    get_addr = False
-                if item in ("-a", "--address"):
-                    get_addr = True
-                if item in ("-p", "--port"):
-                    get_port = True
-        else:
-            self.cmd = [app]
-        self.server = None
-        self.host = f"http://{addr}:{port}"
-
-    async def create(self):
-        """Cerate the server"""
-        self.server = await create_subprocess_exec(*self.cmd)
-        await sleep(1)
-
-    async def destroy(self):
-        """destroy servers"""
-        self.server.terminate()
-        await self.server.wait()
-
-
-class MTTClusterTC(IsolatedAsyncioTestCase):
-    """Test case for MoreThanTText."""
-
-    async def asyncSetUp(self):
-        """Test setup"""
-        self.servers = []
-        self.cookies = {}
-        self.session = ClientSession()
-
-    async def asyncTearDown(self):
-        """Test tear down."""
-        await self.session.close()
-        for server in self.servers:
-            await server.destroy()
-
-    @staticmethod
-    async def get_port():
-        """Retrieve an unused port."""
-        sock = socket()
-        sock.bind((LOCALHOST, 0))
-        port = sock.getsockname()[1]
-        sock.close()
-        return port
-
-    async def create_server_with_flags(self, *args):
-        """Create a single server with flags."""
-        server = Server(*args)
-        await server.create()
-        self.servers.append(server)
-
-    async def create_server(self):
-        """Create a server on a random port."""
-        port = await self.get_port()
-        await self.create_server_with_flags("-p", str(port))
-
-    async def create_cluster(self, num=2):
-        """Create a cluster of servers."""
-        ports = []
-        while len(ports) < num:
-            port = await self.get_port()
-            if port not in ports:
-                ports.append(port)
-        servers = []
-        for port in ports:
-            servers.append(self.create_server_with_flags("-p", str(port)))
-        cluster = gather(*servers)
-        await cluster
-
-    async def run_tests(self, uri, func):
-        """Run the tests on each server."""
-        for server in self.servers:
-            async with self.session.get(
-                f"{server.host}{uri}", cookies=self.cookies
-            ) as response:
-                if SESSION_KEY in response.cookies:
-                    self.cookies[SESSION_KEY] = response.cookies[SESSION_KEY].value
-                func(response)

release_tests/no_test_single_boot.py

@@ -1,102 +0,0 @@
-"""Tests for single server boot ups."""
-
-from socket import gethostbyname, gethostname
-from unittest import skip
-from aiohttp import ClientSession
-from .mtt_tc import MTTClusterTC, SESSION_KEY
-
-
-class BootUpTC(MTTClusterTC):
-    """Single server boot tests."""
-
-    async def test_default_boot(self):
-        """Does the server default boot on http://localhost:3000?"""
-        await self.create_server_with_flags()
-
-        def tests(response):
-            """Response tests."""
-            self.assertEqual(response.status, 200)
-
-        await self.run_tests("/", tests)
-
-    async def test_alt_port_boot(self):
-        """Can the server boot off on alternate port?"""
-        port = 9025
-        await self.create_server_with_flags("-p", str(port))
-
-        def tests(response):
-            """Response tests."""
-            self.assertEqual(response.status, 200)
-
-        await self.run_tests("/", tests)
-
-    async def test_alt_address_boot(self):
-        """Can it boot off an alternate address?"""
-        addr = gethostbyname(gethostname())
-        await self.create_server_with_flags("-a", addr)
-
-        def tests(response):
-            """Response tests."""
-            self.assertEqual(response.status, 200)
-
-        await self.run_tests("/", tests)
-
-    async def test_for_session_id(self):
-        """Is there a session if?"""
-        await self.create_server()
-
-        def tests(response):
-            """Response tests."""
-            self.assertIn(SESSION_KEY, response.cookies)
-
-        await self.run_tests("/", tests)
-
-    async def test_session_id_is_random(self):
-        """Is the session id random?"""
-        await self.create_server()
-        async with ClientSession() as session:
-            async with session.get(f"{self.servers[0].host}/") as response:
-                result1 = response.cookies[SESSION_KEY].value
-        async with ClientSession() as session:
-            async with session.get(f"{self.servers[0].host}/") as response:
-                result2 = response.cookies[SESSION_KEY].value
-        self.assertNotEqual(result1, result2, "Session ids should be unique.")
-
-    @skip("Code not availaable yet.")
-    async def test_session_does_not_reset_after_connection(self):
-        """Does the session id remain constant during the session"""
-        await self.create_server()
-        ids = []
-
-        def tests(response):
-            """tests"""
-            if SESSION_KEY in response.cookies:
-                ids.append(response.cookies[SESSION_KEY].value)
-
-        for _ in range(2):
-            await self.run_tests("/", tests)
-        self.assertEqual(len(ids), 1)
-
-    async def test_reset_bad_session_id(self):
-        """Does the session id get reset if bad or expired?"""
-        await self.create_server()
-        value = "bad id"
-        async with ClientSession() as session:
-            async with session.get(
-                f"{self.servers[0].host}/", cookies={SESSION_KEY: value}
-            ) as response:
-                self.assertIn(SESSION_KEY, response.cookies)
-                self.assertNotEqual(response.cookies[SESSION_KEY].value, value)
-
-    @skip("Code not availaable yet.")
-    async def test_sessions_are_shared_between_servers(self):
-        """Does the session apply to the cluster."""
-        await self.create_cluster()
-        ids = []
-
-        def tests(response):
-            if SESSION_KEY in response.cookies:
-                ids.append(response.cookies[SESSION_KEY].value)
-
-        await self.run_tests("/", tests)
-        self.assertEqual(len(ids), 1, "Session info should be shared to the cluster.")

release_tests/support/__init__.py

@@ -3,6 +3,7 @@
 from socket import socket
 
 ADDR = "127.56.0.1"
+SESSION_KEY = "sessionid"
 
 
 def get_port():

release_tests/support/cluster.py

@@ -1,7 +1,7 @@
 """Create a cluster."""
 
 from aiohttp import ClientSession
-from release_tests.support import get_port
+from release_tests.support import SESSION_KEY, get_port
 from release_tests.support.mttserver import MTTServer
 from release_tests.support.translate import Translate
 
@@ -15,8 +15,9 @@ class Cluster:
         """initialization"""
         self.num = num
         self.translate = Translate(url=transurl, replies=transreplies)
-        self.session = None
+        self.ports = []
         self.servers = []
+        self.cookies = {}
 
     async def start(self):
         """Start the cluster."""
@@ -26,7 +27,6 @@ class Cluster:
             server = MTTServer("-a", ADDR, "-p", port)
             await server.start()
             self.servers.append(server)
-        self.session = ClientSession()
 
     async def start_a_server(self, *args):
         """Creates a single server."""
@@ -34,12 +34,20 @@ class Cluster:
         server = MTTServer(*args)
         await server.start()
         self.servers.append(server)
-        self.session = ClientSession()
+
+    async def start_a_cluster(self):
+        """Start a service cluster."""
+        for _ in range(self.num):
+            port = get_port()
+            while port in self.ports:
+                port = get_port()
+            self.ports.append(port)
+            server = MTTServer("-a", ADDR, "-p", port)
+            await server.start()
+            self.servers.append(server)
 
     async def stop(self):
         """Stops cluster."""
-        if self.session:
-            await self.session.close()
         await self.translate.stop()
         for server in self.servers:
             await server.stop()
@@ -49,11 +57,20 @@ class Cluster:
         await self.stop()
         for server in self.servers:
             await server.cleanup()
+            await server.stop()
 
     async def get(self, url):
         """get from each server in the cluster."""
         replies = []
         for server in self.servers:
-            async with self.session.get(f"{server.baseurl}{url}") as resp:
+            async with ClientSession() as session:
+                async with session.get(
+                    f"{server.baseurl}{url}", cookies=self.cookies
+                ) as resp:
                     replies.append(resp)
         return replies
+
+    async def set_session(self):
+        """Sets up the session ids for the requests."""
+        results = await self.get("/")
+        self.cookies[SESSION_KEY] = results[0].cookies[SESSION_KEY].value

release_tests/test_session.py

@@ -0,0 +1,29 @@
+"""Testing session functions."""
+
+from unittest import IsolatedAsyncioTestCase, skip
+from aiohttp import ClientSession
+from release_tests.support import SESSION_KEY
+from release_tests.support.cluster import Cluster
+
+
+class SessionTC(IsolatedAsyncioTestCase):
+    """Tests the client sessions on a single server."""
+
+    async def asyncSetUp(self):
+        """Set up."""
+        self.cluster = Cluster()
+        await self.cluster.start_a_cluster()
+        self.addAsyncCleanup(self.cluster.cleanup)
+
+    async def test_if_session_added(self):
+        """Is the session created?"""
+        result = await self.cluster.get("/")
+        self.assertIn(SESSION_KEY, result[0].cookies)
+
+    @skip("feature not yet added.")
+    async def test_is_session_shared(self):
+        """Do all of the servers in the cluster use the same session ids?"""
+        results = await self.cluster.get("/")
+        self.assertEqual(
+            results[0].cookies[SESSION_KEY].value, results[1].cookies[SESSION_KEY].value
+        )