feat: implement allocator

Author: matheusmb

allocator/__init__.py

@@ -0,0 +1,3 @@
+from .base_allocator import Allocator
+from .silent_allocator import SilentAllocator
+from .non_silent_allocator import NonSilentAllocator

allocator/base_allocator.py

@@ -0,0 +1,46 @@
+from .name_validator import NameValidator
+
+
+class InvalidHostName(ValueError):
+    def __init__(self, msg):
+        super().__init__()
+        self.message = msg
+
+
+class Allocator:
+    def __init__(self):
+        self.allocated_hosts = dict()
+        self.deallocated_pool = dict()
+
+    def allocate(self, host_type):
+        if not NameValidator.hasValidHostType(host_type):
+            return False
+
+        from_pool = self.getHostFromPool(host_type)
+        if from_pool:
+            return from_pool
+
+        new_instance_num = self.allocated_hosts.get(host_type, 1)
+
+        self.allocated_hosts[host_type] = new_instance_num + 1
+        return f"{host_type}{new_instance_num}"
+
+    def getHostFromPool(self, host_type):
+        host_pool = self.deallocated_pool.get(host_type, None)
+        if host_pool:
+            return host_pool.pop(0)
+
+    def deallocate(self, host_name):
+        if not NameValidator.hasValidHostName(host_name):
+            raise InvalidHostName("Invalid host name")
+
+        host_type, host_id = NameValidator.parseTypeIdFrom(host_name)
+
+        total_allocations = self.allocated_hosts.get(host_type, 0)
+
+        if host_id <= total_allocations:
+            pool = self.deallocated_pool.get(host_type, list())
+            pool.append(host_name)
+            self.deallocated_pool[host_type] = pool
+            return True
+        return False

allocator/name_validator.py

@@ -0,0 +1,29 @@
+import re
+
+class NameValidator:
+    @staticmethod
+    def hasValidHostType(host_type):
+        pattern = r"^[a-z]+$"
+        return re.match(pattern, host_type) is not None
+
+    @staticmethod
+    def hasValidHostName(host_name):
+        pattern = r"^[a-z]+[1-9]+[0-9]*"
+        return re.match(pattern, host_name) is not None
+
+    @staticmethod
+    def parseTypeFrom(host_name):
+        pattern = r"[a-z]+"
+        return re.search(pattern, host_name).group()
+
+    @staticmethod
+    def parseIdFrom(host_name):
+        pattern = r"\d+"
+        id = re.search(pattern, host_name).group()
+        return int(id)
+
+    @staticmethod
+    def parseTypeIdFrom(host_name):
+        return NameValidator.parseTypeFrom(host_name), NameValidator.parseIdFrom(
+            host_name
+        )

allocator/non_silent_allocator.py

@@ -0,0 +1,18 @@
+from .base_allocator import Allocator
+
+
+class NonSilentAllocator(Allocator):
+    def __ini__(self):
+        super().__init__()
+
+    def allocate(self, host_type):
+        allocated_intance = super().allocate(host_type)
+        if allocated_intance:
+            return allocated_intance
+        return "Invalid Name"
+
+    def deallocate(self, host_name):
+        try:
+            return super().deallocate(host_name)
+        except ValueError as e:
+            return e.message

allocator/silent_allocator.py

@@ -0,0 +1,16 @@
+from .base_allocator import Allocator
+
+class SilentAllocator(Allocator):
+    def __init__(self):
+        super().__init__()
+
+    def allocate(self, host_type):
+        allocated_intance = super().allocate(host_type)
+        if allocated_intance:
+            return allocated_intance
+
+    def deallocate(self, host_name):
+        try:
+            super().deallocate(host_name)
+        except:
+            pass

base_test.py

@@ -0,0 +1,93 @@
+import pytest
+
+from allocator import Allocator, SilentAllocator, NonSilentAllocator
+
+
+@pytest.fixture
+def allocator():
+    return Allocator()
+
+
+@pytest.fixture
+def silent_allocator():
+    return SilentAllocator()
+
+
+@pytest.fixture
+def non_silent_allocator():
+    return NonSilentAllocator()
+
+
+def test_should_not_allocate_bad_name(allocator):
+    assert allocator.allocate("invalid_name") is False
+
+
+def test_should_allocate_good_name(allocator):
+    assert allocator.allocate("api") == "api1"
+
+def test_should_allocate_two_times(allocator):
+    assert allocator.allocate("api") == "api1"
+    assert allocator.allocate("api") == "api2"
+
+
+def test_should_allocate_different_hosts(allocator):
+    assert allocator.allocate("api") == "api1"
+    assert allocator.allocate("db") == "db1"
+    assert allocator.allocate("api") == "api2"
+    assert allocator.allocate("db") == "db2"
+
+
+def test_should_return_error_on_bad_name_deallocate(allocator):
+    assert allocator.allocate("api") == "api1"
+    with pytest.raises(ValueError):
+        assert allocator.deallocate("invalid_name") is False
+
+
+def test_should_allocate_deallocate(allocator):
+    assert allocator.allocate("api") == "api1"
+    assert allocator.deallocate("api1") is True
+
+
+def test_should_not_deallocate_on_not_allocated(allocator):
+    assert allocator.deallocate("db1") is False
+    assert allocator.allocate("api") == "api1"
+    assert allocator.deallocate("api1") is True
+
+
+def test_should_use_previous_deallocated_type(allocator):
+    assert allocator.allocate("api") == "api1"
+    assert allocator.deallocate("api1") is True
+    assert allocator.allocate("api") == "api1"
+
+
+def test_should_allocate_and_deallocate_sequentially(allocator):
+    assert allocator.allocate("api") == "api1"
+    assert allocator.allocate("api") == "api2"
+    assert allocator.allocate("api") == "api3"
+
+    assert allocator.allocate("db") == "db1"
+    assert allocator.allocate("api") == "api4"
+    assert allocator.allocate("db") == "db2"
+
+    assert allocator.deallocate("db1") == True
+    assert allocator.deallocate("api2") == True
+    assert allocator.deallocate("api1") == True
+
+    assert allocator.allocate("api") == "api2"
+    assert allocator.allocate("db") == "db1"
+    assert allocator.allocate("api") == "api1"
+    assert allocator.allocate("api") == "api5"
+
+
+def test_silent_allocator(silent_allocator):
+    assert silent_allocator.allocate("api") == "api1"
+    assert silent_allocator.allocate("invalid_name") is None
+    assert silent_allocator.deallocate("invalid_name") is None
+    assert silent_allocator.deallocate("api1") is None
+
+
+def test_non_silent_allocator(non_silent_allocator):
+    assert non_silent_allocator.allocate("api") == "api1"
+    assert non_silent_allocator.allocate("invalid_name") == "Invalid Name"
+    assert non_silent_allocator.deallocate("invalid_name") == "Invalid host name"
+    assert non_silent_allocator.deallocate("api1") is True