unit tests added

Author: minduca

src/autocomplete/levenshteinTrie.py

@@ -21,12 +21,12 @@ class LevenshteinTrie:
     def __init__(self):
         self._root: TrieNode = TrieNode(letter="", wordpath="")
 
-    def insert(self, word: str, owner: object) -> None:
-        self._root.insert(word.lower(), owner)
+    def insert(self, word: str, owner: object=None) -> None:
+        self._root.insert(word.lower(), word, owner)
 
     # The search function returns a list of all words that are less than the
     # given maximum distance from the target word
-    def search(self, word: str, maxCost: int) -> List[NodeMatch]:
+    def search(self, word: str, maxCost: int) -> List[ResultMatch]:
 
         cumulativeResult: List[NodeMatch] = []
         tracker = LevenshteinTracker(word.lower(), maxCost)
@@ -35,7 +35,7 @@ def search(self, word: str, maxCost: int) -> List[NodeMatch]:
             self._searchBranch(
                 self._root.children[char], cumulativeResult, tracker)
 
-        return list(map(lambda n: ResultMatch(n.node.wordpath, n.node.owner, n.cost), cumulativeResult))
+        return list(map(lambda n: ResultMatch(n.node.finalword, n.node.owner, n.cost), cumulativeResult))
 
     def _searchBranch(self, node: TrieNode, cumulativeResult: List[NodeMatch], tracker: LevenshteinTracker):
 

src/autocomplete/resultMatch.py

@@ -7,4 +7,4 @@ def __init__(self, word: str, owner: object, cost: int):
         self.cost: int = cost
 
     def __repr__(self):
-        return "'{}' -> {} ({})".format(self.word, self.owner, self.cost)
+        return "'{}' - {}".format(self.word, self.cost)

src/autocomplete/trieNode.py

@@ -5,12 +5,14 @@ class TrieNode:
     def __init__(self, letter: str, wordpath: str):
         self.letter: str = letter
         self.wordpath: str = wordpath
+        self.finalword: str = None
         self.owner: object = None
         self.children: Dict[str, TrieNode] = {}
 
-    def insert(self, wordpath: str, owner: object) -> None:
-        leaf: TrieNode = self._createOrGetLeaf(wordpath)
-        leaf.owner = owner
+    def insert(self, wordparsed: str, finalword: str, owner: object=None) -> None:
+        leaf: TrieNode = self._createOrGetLeaf(wordparsed)
+        leaf.finalword = finalword
+        leaf.owner = owner if owner is not None else finalword
 
     def isWholeWord(self) -> bool:
         return self.owner is not None

src/hello/search/placeSearchEngine.py

@@ -22,11 +22,12 @@ def search(self, query) -> PlaceSearchResult:
         if query:
             queryParsed: str = query.strip()
 
-        if queryParsed:
+        start = time.time()
 
-            start = time.time()
+        if queryParsed:
             places = self._searchStrategy.search(queryParsed)
-            end = time.time()
             places = places[0:self._config.maxNumberResults]
 
+        end = time.time()
+
         return PlaceSearchResult(places, start, end)

src/src.pyproj

@@ -56,7 +56,6 @@
     <Compile Include="hello\search\placeSearchEngine.py">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="hello\search\placeSearchQueryStrategyNew.py" />
     <Compile Include="hello\search\placeSearchQueryStrategy.py">
       <SubType>Code</SubType>
     </Compile>
@@ -66,7 +65,6 @@
     <Compile Include="hello\search\placeSearchResult.py">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="hello\search\trienew.py" />
     <Compile Include="hello\search\trie.py">
       <SubType>Code</SubType>
     </Compile>
@@ -90,19 +88,12 @@
   </ItemGroup>
   <ItemGroup>
     <Folder Include="autocomplete\" />
-    <Folder Include="autocomplete\__pycache__\" />
     <Folder Include="hello\" />
     <Folder Include="hello\endpoints\" />
     <Folder Include="hello\search\" />
   </ItemGroup>
   <ItemGroup>
     <Content Include=".pylintrc" />
-    <Content Include="autocomplete\__pycache__\levenshteinTracker.cpython-36.pyc" />
-    <Content Include="autocomplete\__pycache__\levenshteinTrie.cpython-36.pyc" />
-    <Content Include="autocomplete\__pycache__\resultMatch.cpython-36.pyc" />
-    <Content Include="autocomplete\__pycache__\trienew.cpython-36.pyc" />
-    <Content Include="autocomplete\__pycache__\trieNode.cpython-36.pyc" />
-    <Content Include="autocomplete\__pycache__\__init__.cpython-36.pyc" />
     <Content Include="requirements.txt" />
   </ItemGroup>
   <ItemGroup>

test/test.pyproj

@@ -29,13 +29,17 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="runserver.py" />
+    <Compile Include="test\autocomplete\test_levenshteinTrie.py">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="test\search\test_placeSearchEngine.py">
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="test\__init__.py" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="test\" />
+    <Folder Include="test\autocomplete\" />
     <Folder Include="test\search\" />
   </ItemGroup>
   <ItemGroup>

test/test/autocomplete/test_levenshteinTrie.py

@@ -0,0 +1,49 @@
+import unittest
+from typing import Tuple, List
+from unittest.mock import MagicMock
+from autocomplete.levenshteinTrie import LevenshteinTrie
+from autocomplete.resultMatch import ResultMatch
+
+class Test_LevenshteinTrie(unittest.TestCase):
+
+    def test_emptytree_emptyresult(self):
+        
+        self.search_DataDrivenTest(
+            database=(), 
+            query="any", maxCost=3, 
+            expectedResult=[])
+
+    def test_search_partialWord_approximatedWordsReturned(self):
+        
+        self.search_DataDrivenTest(
+            database=("Batman", "Robin", "Batman & Robin", "Wonder Woman", "Robin Hood", "Batgirl & Robin"), 
+            query="bat man", maxCost=3, 
+            expectedResult=["Batman", "Batman & Robin"])
+
+    def test_search_similarWord_approximatedWordsReturned(self):
+        
+        self.search_DataDrivenTest(
+            database=("Batman", "Robin", "Batman & Robin", "Wonder Woman", "Robin Hood", "Batgirl & Robin"), 
+            query="bat man & rboin", maxCost=3, 
+            expectedResult=["Batman & Robin"])
+
+    def search_DataDrivenTest(self, database: Tuple[str,...], query:str, maxCost: int, expectedResult: Tuple[str,...]) -> List[ResultMatch]:
+        
+        #arrange
+        trie: LevenshteinTrie = self.createTrie(database)
+
+        #act
+        result: List[ResultMatch] = trie.search(query, maxCost)
+
+        #assert
+        assert len(result) == len(expectedResult)
+        assert all(r.word in expectedResult for r in result)
+
+    def createTrie(self, words: Tuple[str, ...]) -> LevenshteinTrie:
+        
+        trie = LevenshteinTrie()
+
+        for word in words:
+            trie.insert(word)
+
+        return trie

test/test/search/test_placeSearchEngine.py

@@ -4,64 +4,64 @@
 
 from hello.search.placeSearchEngine import PlaceSearchEngine
 from hello.search.placeSearchConfig import PlaceSearchConfig
-from hello.search.placeSearchQueryStrategy import IPlaceSearchStrategy
-from hello.place import Place
+from hello.search.placeSearchResult import PlaceSearchResult
+from hello.core import IPlaceSearchQueryStrategy, PlaceScore
 
 class Test_placeSearchEngine(unittest.TestCase):
 
     def test_search_emptyStrategyResult_emptyCollection(self):
         #arrange
-        query = 'auto'
-        strategy: IPlaceSearchStrategy = self.createStrategy(result=())
+        query:str = 'auto'
+        strategy: IPlaceSearchQueryStrategy = self.createStrategy(result=())
         config = PlaceSearchConfig(maxNumberResults=10)
         engine = PlaceSearchEngine(strategy, config)
 
         #act
-        result: Tuple[Place] = engine.search(query)
+        result: PlaceSearchResult = engine.search(query)
 
         #assert
-        assert len(result) == 0
+        assert len(result.places) == 0
         assert strategy.search.called
 
     def test_search_emptyQuery_emptyCollection(self):
         #arrange
-        query = ''
-        strategy: IPlaceSearchStrategy = self.createStrategy(result=())
+        query:str = ''
+        strategy: IPlaceSearchQueryStrategy = self.createStrategy(result=())
         config = PlaceSearchConfig(maxNumberResults=10)
         engine = PlaceSearchEngine(strategy, config)
 
         #act
-        result: Tuple[Place] = engine.search(query)
+        result: PlaceSearchResult = engine.search(query)
 
         #assert
-        self.assertEqual(len(result), 0)
+        assert len(result.places) == 0
         assert not strategy.search.called
 
     def test_search_invalidConfig_error(self):
         #arrange
-        query = 'auto'
-        strategy: IPlaceSearchStrategy = self.createStrategy(result=())
+        query:str = 'auto'
+        strategy: IPlaceSearchQueryStrategy = self.createStrategy(result=())
         config = PlaceSearchConfig(maxNumberResults=0)
         engine = PlaceSearchEngine(strategy, config)
 
         #act / assert
         self.assertRaises(ValueError, engine.search, query)
 
-    def test_search_queryCaseEmptySpaces_queryParsed(self):
+    def test_search_queryTrailingSpaces_queryParsed(self):
         #arrange
-        query = ' Auto Complete  '
-        strategy: IPlaceSearchStrategy = self.createStrategy(result=())
+        query:str = ' Auto Complete  '
+        strategy: IPlaceSearchQueryStrategy = self.createStrategy(result=())
         config = PlaceSearchConfig(maxNumberResults=2)
         engine = PlaceSearchEngine(strategy, config)
 
         #act
-        result: Tuple[Place] = engine.search(query)
+        result: PlaceSearchResult = engine.search(query)
 
         #assert
-        strategy.search.assert_called_with('auto complete')
+        strategy.search.assert_called_with('Auto Complete')
 
-    def createStrategy(self, result: Tuple[Place]) -> IPlaceSearchStrategy:
-        strategy = IPlaceSearchStrategy()
+    def createStrategy(self, result: Tuple[PlaceScore]) -> IPlaceSearchQueryStrategy:
+        strategy = IPlaceSearchQueryStrategy()
         strategy.search = MagicMock(return_value=result)
         return strategy