Replaced start up tests.

release_tests/support/cluster.py

@@ -1,35 +1,55 @@
 """Create a cluster."""
 
 from aiohttp import ClientSession
+from release_tests.support import get_port
 from release_tests.support.mttserver import MTTServer
 from release_tests.support.translate import Translate
 
+ADDR = "127.56.0.1"
+
 
 class Cluster:
     """cluster of MoreThanText."""
 
     def __init__(self, num=2, transurl=None, transreplies=None):
         """initialization"""
+        self.num = num
         self.translate = Translate(url=transurl, replies=transreplies)
         self.session = None
         self.servers = []
-        for _ in range(num):
-            self.servers.append(MTTServer())
 
     async def start(self):
         """Start the cluster."""
         await self.translate.start()
-        for server in self.servers:
+        for _ in range(self.num):
+            port = get_port()
+            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."""
+        self.num = 1
+        server = MTTServer(*args)
+        await server.start()
+        self.servers.append(server)
         self.session = ClientSession()
 
     async def stop(self):
         """Stops cluster."""
-        await self.session.close()
+        if self.session:
+            await self.session.close()
         await self.translate.stop()
         for server in self.servers:
             await server.stop()
 
+    async def cleanup(self):
+        """Cleans up the cluster."""
+        await self.stop()
+        for server in self.servers:
+            await server.cleanup()
+
     async def get(self, url):
         """get from each server in the cluster."""
         replies = []

release_tests/support/mttserver.py

@@ -3,7 +3,6 @@
 from asyncio import create_subprocess_exec
 from socket import AF_INET, SOCK_STREAM, socket
 from pathlib import Path
-from release_tests.support import ADDR, get_port
 
 EXECUTABLE = Path.cwd().joinpath("target", "release", "morethantext")
 
@@ -11,27 +10,51 @@ EXECUTABLE = Path.cwd().joinpath("target", "release", "morethantext")
 class MTTServer:
     """Runs a MoreThanText server."""
 
-    def __init__(self):
+    def __init__(self, *args):
         """Initialization"""
-        self.port = get_port()
+        self.port = 3000
-        self.cmd = [EXECUTABLE, "-a", ADDR, "-p", str(self.port)]
+        self.address = "127.0.0.1"
+        self.cmd = [EXECUTABLE]
+        for item in list(args):
+            self.cmd.append(str(item))
+        try:
+            self.port = self.cmd[self.cmd.index("-p") + 1]
+        except ValueError:
+            pass
+        try:
+            self.port = self.cmd[self.cmd.index("--port") + 1]
+        except ValueError:
+            pass
+        try:
+            self.address = self.cmd[self.cmd.index("-a") + 1]
+        except ValueError:
+            pass
+        try:
+            self.address = self.cmd[self.cmd.index("--address") + 1]
+        except ValueError:
+            pass
         self.server = None
 
     @property
     def baseurl(self):
         """URL to server"""
-        return f"http://{ADDR}:{self.port}"
+        return f"http://{self.address}:{self.port}"
 
     async def start(self):
         """Starts the server."""
         self.server = await create_subprocess_exec(*self.cmd)
         # delays the return untul the serverr is responding.
         with socket(AF_INET, SOCK_STREAM) as soc:
-            while soc.connect_ex((ADDR, self.port)) != 0:
+            while soc.connect_ex((self.address, int(self.port))) != 0:
                 continue
 
     async def stop(self):
         """Stops the server."""
         if self.server:
-            self.server.terminate()
+            if not self.server.returncode:
-            await self.server.wait()
+                self.server.terminate()
+                await self.server.wait()
+
+    async def cleanup(self):
+        """Clean up."""
+        await self.stop()

release_tests/support/test_cluster.py

@@ -31,7 +31,9 @@ class ClusterTC(IsolatedAsyncioTestCase):
         """Control the number of servers."""
         count = 3
         cluster = Cluster(num=count)
+        await cluster.start()
         self.assertEqual(len(cluster.servers), count)
+        await cluster.cleanup()
 
     async def test_set_translation_mocking(self):
         """Is the translation mocking setup"""

release_tests/support/test_mttserver.py

@@ -2,7 +2,7 @@
 
 from unittest import IsolatedAsyncioTestCase
 from aiohttp import ClientSession
-from release_tests.support import ADDR
+from release_tests.support import get_port
 from release_tests.support.mttserver import MTTServer
 
 
@@ -13,9 +13,23 @@ class MTTServerTC(IsolatedAsyncioTestCase):
         """Test default start up."""
         mtt = MTTServer()
         await mtt.start()
-        url = f"http://{ADDR}:{mtt.port}"
+        url = mtt.baseurl
+        self.assertEqual(url, "http://127.0.0.1:3000")
         async with ClientSession() as session:
             async with session.get(url) as resp:
                 text = await resp.text()
                 self.assertEqual(resp.status, 200, text)
-                self.assertEqual(mtt.baseurl, url)
+        await mtt.cleanup()
+
+    async def test_flags(self):
+        """Make sure flags are working."""
+        host = "127.28.56.13"
+        port = get_port()
+        mtt = MTTServer("-a", host, "-p", port)
+        self.assertEqual(mtt.baseurl, f"http://{host}:{port}")
+        await mtt.start()
+        async with ClientSession() as session:
+            async with session.get(mtt.baseurl) as resp:
+                text = await resp.text()
+                self.assertEqual(resp.status, 200, text)
+        await mtt.cleanup()

release_tests/support/translate.py

@@ -41,4 +41,5 @@ class Translate:
 
     async def stop(self):
         """Stops the application."""
-        await self.runner.cleanup()
+        if self.runner:
+            await self.runner.cleanup()

release_tests/test_startup.py

@@ -0,0 +1,45 @@
+"""Test release startup conditions."""
+
+from socket import gethostbyname, gethostname
+from unittest import IsolatedAsyncioTestCase
+from aiohttp import ClientSession
+from release_tests.support import get_port
+from release_tests.support.cluster import Cluster
+
+LOCALHOST = "127.0.0.1"
+DEFAULT_PORT = 3000
+
+
+class MTTStartUp(IsolatedAsyncioTestCase):
+    """Tests the server startup conditions."""
+
+    async def asyncSetUp(self):
+        """Setup for server testing."""
+        self.cluster = Cluster()
+        self.addAsyncCleanup(self.cluster.cleanup)
+
+    async def test_default_startup(self):
+        """Does the server start up on localhost:3000"""
+        url = f"http://{LOCALHOST}:{DEFAULT_PORT}"
+        await self.cluster.start_a_server()
+        async with ClientSession() as session:
+            async with session.get(url) as resp:
+                self.assertEqual(resp.status, 200)
+
+    async def test_address(self):
+        """Can the address be set?"""
+        addr = gethostbyname(gethostname())
+        url = f"http://{addr}:{DEFAULT_PORT}"
+        await self.cluster.start_a_server("-a", addr)
+        async with ClientSession() as session:
+            async with session.get(url) as resp:
+                self.assertEqual(resp.status, 200)
+
+    async def test_port(self):
+        """Can the port be changed?"""
+        port = get_port()
+        url = f"http://{LOCALHOST}:{port}"
+        await self.cluster.start_a_server("-p", port)
+        async with ClientSession() as session:
+            async with session.get(url) as resp:
+                self.assertEqual(resp.status, 200)