[tests] Add tests for repository level analysis via lizard

Signed-off-by: inishchith <[email protected]>

Author: inishchith

graal/backends/core/analyzers/lizard.py

@@ -100,6 +100,8 @@ def __analyze_repository(self, repository_path, details):
             }
             analysis_result.append(result)
 
+        # TODO: implement details option
+
         return analysis_result
 
     def analyze(self, **kwargs):

tests/test_cocom.py

@@ -27,12 +27,15 @@
 import tempfile
 import unittest.mock
 
+from graal.graal import GraalError
 from graal.graal import GraalCommandArgumentParser
 from graal.backends.core.analyzers.cloc import Cloc
 from graal.backends.core.analyzers.lizard import Lizard
-from graal.backends.core.cocom import (CATEGORY_COCOM,
+from graal.backends.core.cocom import (CATEGORY_COCOM_LIZARD_FILE,
+                                       CATEGORY_COCOM_LIZARD_REPOSITORY,
                                        CoCom,
                                        FileAnalyzer,
+                                       RepositoryAnalyzer,
                                        CoComCommand)
 from perceval.utils import DEFAULT_DATETIME
 from test_graal import TestCaseGraal
@@ -80,15 +83,13 @@ def test_initialization(self):
         self.assertEqual(cc.worktreepath, os.path.join(self.worktree_path, os.path.split(cc.gitpath)[1]))
         self.assertEqual(cc.origin, 'http://example.com')
         self.assertEqual(cc.tag, 'test')
-        self.assertEqual(cc.file_analyzer.details, False)
 
         cc = CoCom('http://example.com', self.git_path, self.worktree_path, details=True, tag='test')
         self.assertEqual(cc.uri, 'http://example.com')
         self.assertEqual(cc.gitpath, self.git_path)
         self.assertEqual(cc.worktreepath, os.path.join(self.worktree_path, os.path.split(cc.gitpath)[1]))
         self.assertEqual(cc.origin, 'http://example.com')
         self.assertEqual(cc.tag, 'test')
-        self.assertEqual(cc.file_analyzer.details, True)
 
         # When tag is empty or None it will be set to the value in uri
         cc = CoCom('http://example.com', self.git_path, self.worktree_path)
@@ -99,8 +100,8 @@ def test_initialization(self):
         self.assertEqual(cc.origin, 'http://example.com')
         self.assertEqual(cc.tag, 'http://example.com')
 
-    def test_fetch(self):
-        """Test whether commits are properly processed"""
+    def test_fetch_lizard_file(self):
+        """Test whether commits are properly processed via file level"""
 
         cc = CoCom('http://example.com', self.git_path, self.worktree_path, in_paths=['perceval/backends/core/github.py'])
         commits = [commit for commit in cc.fetch()]
@@ -110,7 +111,7 @@ def test_fetch(self):
 
         for commit in commits:
             self.assertEqual(commit['backend_name'], 'CoCom')
-            self.assertEqual(commit['category'], CATEGORY_COCOM)
+            self.assertEqual(commit['category'], CATEGORY_COCOM_LIZARD_FILE)
             self.assertEqual(commit['data']['analysis'][0]['file_path'],
                              'perceval/backends/core/github.py')
             self.assertTrue('Author' in commit['data'])
@@ -119,10 +120,36 @@ def test_fetch(self):
             self.assertFalse('parents' in commit['data'])
             self.assertFalse('refs' in commit['data'])
 
+    def test_fetch_lizard_repository(self):
+        """Test whether commits are properly processed via repository level"""
+
+        cc = CoCom('http://example.com', self.git_path, self.worktree_path)
+        commits = [commit for commit in cc.fetch(category="code_complexity_lizard_repository")]
+
+        self.assertEqual(len(commits), 6)
+        self.assertFalse(os.path.exists(cc.worktreepath))
+
+        for commit in commits:
+            self.assertEqual(commit['backend_name'], 'CoCom')
+            self.assertEqual(commit['category'], CATEGORY_COCOM_LIZARD_REPOSITORY)
+            self.assertTrue('Author' in commit['data'])
+            self.assertTrue('Commit' in commit['data'])
+            self.assertFalse('files' in commit['data'])
+            self.assertFalse('parents' in commit['data'])
+            self.assertFalse('refs' in commit['data'])
+
+    def test_fetch_unknown(self):
+        """Test whether commits are properly processed"""
+
+        cc = CoCom('http://example.com', self.git_path, self.worktree_path)
+
+        with self.assertRaises(GraalError):
+            _ = cc.fetch(category="unknown")
+
     def test_fetch_analysis(self):
         """Test whether commits have properly set values"""
 
-        cc = CoCom('http://example.com', self.git_path, self.worktree_path)
+        cc = CoCom('http://example.com', self.git_path, self.worktree_path, details=True)
         commits = [commit for commit in cc.fetch()]
 
         self.assertEqual(len(commits), 6)
@@ -141,6 +168,46 @@ def test_fetch_analysis(self):
         self.assertEqual(deleted_file_commit['data']['analysis'][0]['avg_tokens'], None)
         self.assertEqual(deleted_file_commit['data']['analysis'][0]['num_funs'], None)
         self.assertEqual(deleted_file_commit['data']['analysis'][0]['tokens'], None)
+        self.assertEqual(deleted_file_commit['data']['analysis'][0]['funs'], [])
+
+    def test_metadata_category(self):
+        """Test metadata_category"""
+        item = {
+            "Author": "Nishchith Shetty <[email protected]>",
+            "AuthorDate": "Tue Feb 26 22:06:31 2019 +0530",
+            "Commit": "Nishchith Shetty <[email protected]>",
+            "CommitDate": "Tue Feb 26 22:06:31 2019 +0530",
+            "analysis": [],
+            "analyzer": "lizard_file",
+            "commit": "5866a479587e8b548b0cb2d591f3a3f5dab04443",
+            "message": "[copyright] Update copyright dates"
+        }
+        self.assertEqual(CoCom.metadata_category(item), CATEGORY_COCOM_LIZARD_FILE)
+
+        item = {
+            "Author": "Nishchith Shetty <[email protected]>",
+            "AuthorDate": "Tue Feb 26 22:06:31 2019 +0530",
+            "Commit": "Nishchith Shetty <[email protected]>",
+            "CommitDate": "Tue Feb 26 22:06:31 2019 +0530",
+            "analysis": [],
+            "analyzer": "lizard_repository",
+            "commit": "5866a479587e8b548b0cb2d591f3a3f5dab04443",
+            "message": "[copyright] Update copyright dates"
+        }
+        self.assertEqual(CoCom.metadata_category(item), CATEGORY_COCOM_LIZARD_REPOSITORY)
+
+        item = {
+            "Author": "Nishchith Shetty <[email protected]>",
+            "AuthorDate": "Tue Feb 26 22:06:31 2019 +0530",
+            "Commit": "Nishchith Shetty <[email protected]>",
+            "CommitDate": "Tue Feb 26 22:06:31 2019 +0530",
+            "analysis": [],
+            "analyzer": "unknown",
+            "commit": "5866a479587e8b548b0cb2d591f3a3f5dab04443",
+            "message": "[copyright] Update copyright dates"
+        }
+        with self.assertRaises(GraalError):
+            _ = CoCom.metadata_category(item)
 
 
 class TestFileAnalyzer(TestCaseAnalyzer):
@@ -206,6 +273,39 @@ def test_analyze_functions(self):
             self.assertIn('end', fd)
 
 
+class TestRepositoryAnalyzer(TestCaseAnalyzer):
+    """RepositoryAnalyzer tests"""
+
+    def test_init(self):
+        """Test initialization"""
+
+        repository_analyzer = RepositoryAnalyzer()
+
+        self.assertIsInstance(repository_analyzer, RepositoryAnalyzer)
+        self.assertIsInstance(repository_analyzer.lizard, Lizard)
+        self.assertFalse(repository_analyzer.details)
+
+        repository_analyzer = RepositoryAnalyzer(details=True)
+
+        self.assertIsInstance(repository_analyzer, RepositoryAnalyzer)
+        self.assertIsInstance(repository_analyzer.lizard, Lizard)
+        self.assertTrue(repository_analyzer.details)
+
+    def test_analyze(self):
+        """Test whether the analyze method works"""
+
+        repository_path = self.tmp_data_path
+        repository_analyzer = RepositoryAnalyzer()
+        analysis = repository_analyzer.analyze(repository_path)
+
+        file_analysis = analysis[0]
+
+        self.assertIn('num_funs', file_analysis)
+        self.assertIn('ccn', file_analysis)
+        self.assertIn('loc', file_analysis)
+        self.assertIn('tokens', file_analysis)
+
+
 class TestCoComCommand(unittest.TestCase):
     """CoComCommand tests"""
 

tests/test_lizard.py

@@ -33,8 +33,8 @@
 class TestLizard(TestCaseAnalyzer):
     """Lizard tests"""
 
-    def test_analyze_no_details(self):
-        """Test whether lizard returns the expected fields data"""
+    def test_analyze_file_no_details(self):
+        """Test whether lizard returns the expected fields data for files"""
 
         lizard = Lizard()
         kwargs = {'file_path': os.path.join(self.tmp_data_path, ANALYZER_TEST_FILE),
@@ -57,8 +57,8 @@ def test_analyze_no_details(self):
         self.assertIn('tokens', result)
         self.assertTrue(type(result['tokens']), int)
 
-    def test_analyze_details(self):
-        """Test whether lizard returns the expected fields data"""
+    def test_analyze_file_details(self):
+        """Test whether lizard returns the expected fields data for files"""
 
         lizard = Lizard()
         kwargs = {'file_path': os.path.join(self.tmp_data_path, ANALYZER_TEST_FILE),
@@ -100,6 +100,25 @@ def test_analyze_details(self):
             self.assertIn('end', fd)
             self.assertTrue(type(fd['end']), int)
 
+    def test_analyze_repository(self):
+        """Test whether lizard returns the expected fields data for repository"""
+
+        lizard = Lizard()
+        kwargs = {'repository_path': self.tmp_data_path,
+                  'repository_level': True,
+                  'details': False}
+        result = lizard.analyze(**kwargs)
+        result = result[0]
+
+        self.assertIn('ccn', result)
+        self.assertTrue(type(result['ccn']), int)
+        self.assertIn('num_funs', result)
+        self.assertTrue(type(result['num_funs']), int)
+        self.assertIn('loc', result)
+        self.assertTrue(type(result['loc']), int)
+        self.assertIn('tokens', result)
+        self.assertTrue(type(result['tokens']), int)
+
 
 if __name__ == "__main__":
     unittest.main()