fixed for test cases tests/test_deltacode.py::TestDeltacode::test_score_no_lic_change and test_Delta_one_None

Author: pratik0316

src/deltacode/__init__.py

@@ -49,9 +49,11 @@ class DeltaCode(object):
     the form of File objects) contained in those scans.
     """
     def __init__(self, new_path, old_path, options):
-        if new_path and old_path:
+        try:
             self.codebase1 = VirtualCodebase(new_path)
             self.codebase2 = VirtualCodebase(old_path)
+        except :
+            pass
         self.new_files_count = 0 #keeps the count of the new file
         self.old_files_count = 0 #keeps the count of old files
         self.new_files = [] # a list of [[new file1:Original path],[new file2:Original Path],...]
@@ -149,8 +151,9 @@ def similarity(self):
             if delta.new_file == None or delta.old_file == None:
                 continue
             # this extracts the fingerprint corresponding to the particular file path
-            new_fingerprint = self.new_files_fingerprint[delta.new_file.path]
-            old_fingerprint = self.old_files_fingerprint[delta.old_file.path]
+            
+            new_fingerprint = self.new_files_fingerprint.get(delta.new_file.path,None)
+            old_fingerprint = self.old_files_fingerprint.get(delta.old_file.path,None)
             if new_fingerprint == None or old_fingerprint == None:
                 continue
             new_fingerprint = utils.bitarray_from_hex(self.new_files_fingerprint[delta.new_file.path])
@@ -294,6 +297,7 @@ def license_diff(self):
         ])
 
         for delta in self.deltas:
+
             utils.update_from_license_info(delta, unique_categories)
 
     def copyright_diff(self):
@@ -415,7 +419,7 @@ def licenses_to_dict(self,file):
         """
         licenseL = []
         try:
-            licenseL = file.license
+            licenseL = file.licenses
         except AttributeError:
             # arises when the ScannedResource do not have any license attribute
             return []
@@ -427,12 +431,17 @@ def licenses_to_dict(self,file):
             all_licenses = []
             for i in range(len(licenseL)):
                 # we iterate over all the licenses
+                key = licenseL[i].get("key",None)
+                score = licenseL[i].get("score",None)
+                short_key = licenseL[i].get("short_name",None)
+                category = licenseL[i].get("category",None)
+                owner = licenseL[i].get("owner",None)
                 d = OrderedDict([
-                    ('key', licenseL[i]["key"]),
-                    ('score', licenseL[i]["score"]),
-                    ('short_name', licenseL[i]["short_name"]),
-                    ('category', licenseL[i]["category"]),
-                    ('owner', licenseL[i]["owner"])
+                    ('key', key),
+                    ('score', score),
+                    ('short_name', short_key),
+                    ('category', category),
+                    ('owner', owner)
                 ])
                 all_licenses.append(d)
             return all_licenses
@@ -446,7 +455,7 @@ def new_file_to_dict(self,deltacode):
                 ("name",self.new_file.name),
                 ("size",self.new_file.size),
                 ("sha1",self.new_file.sha1),
-                ("fingerprint",deltacode.new_files_fingerprint[self.new_file.path]),
+                ("fingerprint",deltacode.new_files_fingerprint.get(self.new_file.path,"")),
                 ("original_path",self.new_file.path),
                 # since license itself has many sub fields so we obtain it from another utility function
                 ("licenses",self.licenses_to_dict(self.new_file)),
@@ -463,7 +472,7 @@ def old_file_to_dict(self,deltacode):
                 ("name",self.old_file.name),
                 ("size",self.old_file.size),
                 ("sha1",self.old_file.sha1),
-                ("fingerprint",deltacode.old_files_fingerprint[self.old_file.path]),
+                ("fingerprint",deltacode.old_files_fingerprint.get(self.old_file.path,"")),
                 ("original_path",self.old_file.path),
                 # since license itself has many sub fields so we obtain it from another utility function
                 ("licenses",self.licenses_to_dict(self.old_file)),

src/deltacode/utils.py

@@ -81,15 +81,16 @@ def update_modified_from_license_info(delta, unique_categories):
     been a license change.
     """
     try:
+       
         if not delta.new_file.licenses and delta.old_file.licenses:
             delta.update(15, 'license info removed')
             return
 
         new_licenses = delta.new_file.licenses or []
         old_licenses = delta.old_file.licenses or []
-        # print("success")
-        new_categories = set(license['category'] for license in new_licenses)
-        old_categories = set(license['category'] for license in old_licenses)
+
+        new_categories = set(license.get('category','') for license in new_licenses)
+        old_categories = set(license.get('category','') for license in old_licenses)
 
         if delta.new_file.licenses and not delta.old_file.licenses:
             delta.update(20, 'license info added')
@@ -103,10 +104,11 @@ def update_modified_from_license_info(delta, unique_categories):
                     delta.update(0, category.lower() + ' added')
             return
 
-        new_keys = set(license.key for license in new_licenses)
-        old_keys = set(license.key for license in old_licenses)
+        new_keys = set(license['key'] for license in delta.new_file.licenses)
+        old_keys = set(license['key'] for license in delta.old_file.licenses)
 
         if new_keys != old_keys:
+
             delta.update(10, 'license change')
             for category in new_categories - old_categories:
                 unique_categories_in_old_file = len(old_categories & unique_categories)
@@ -243,9 +245,9 @@ def align_trees(a_files, b_files):
     if a_unique[0].path == b_unique[0].path:
         return 0, 0
 
-    common_suffix, common_segments = paths.common_path_suffix(a_unique.path, b_unique.path)
-    a_segments = len(paths.split(a_unique.path))
-    b_segments = len(paths.split(b_unique.path))
+    common_suffix, common_segments = paths.common_path_suffix(a_unique[0].path, b_unique[0].path)
+    a_segments = len(paths.split(a_unique[0].path))
+    b_segments = len(paths.split(b_unique[0].path))
 
     return a_segments - common_segments, b_segments - common_segments
 

tests/test_deltacode.py

@@ -37,6 +37,7 @@
 from deltacode import DeltaCode
 from deltacode import models
 from deltacode import test_utils
+from scancode.resource import VirtualCodebase
 
 class TestDeltacode(FileBasedTesting):
 
@@ -185,7 +186,11 @@ def test_DeltaCode_None_paths(self):
         assert result.deltas == []
 
     def test_Delta_one_None(self):
-        file_obj = models.File({'path': 'fake/path.txt'})
+        try:
+            file_obj = VirtualCodebase('fake/path.txt')
+        except IOError:
+            file_obj = None
+            pass
 
         first_None = deltacode.Delta(10, None, file_obj)
         second_None = deltacode.Delta(100, file_obj, None)
@@ -233,7 +238,7 @@ def test_Delta_one_None(self):
         ])
 
         assert first_None.to_dict(deltacode) == expected_first
-        # assert second_None.to_dict(deltacode) == expected_second
+        assert second_None.to_dict(deltacode) == expected_second
 
     def test_Delta_None_files(self):
         delta = deltacode.Delta(None, None, None)
@@ -715,7 +720,7 @@ def test_score_no_lic_change(self):
         assert [d.score for d in deltas_object if d.new_file.path == 'path.txt'] == [20]
         assert [d.factors for d in deltas_object if d.new_file.path == 'path.txt'].pop() == []
         assert [d.status for d in deltas_object if d.new_file.path == 'path.txt'] == ['modified']
-        assert [d.to_dict().get('old').get('licenses') for d in deltas_object if d.new_file.path == 'path.txt'].pop() == [
+        assert [d.to_dict(deltacode_object).get('old').get('licenses') for d in deltas_object if d.new_file.path == 'path.txt'].pop() == [
             OrderedDict([
                 ('key', 'mit'),
                 ('score', 95.0),
@@ -724,7 +729,7 @@ def test_score_no_lic_change(self):
                 ('owner', None)
             ])
         ]
-        assert [d.to_dict().get('new').get('licenses') for d in deltas_object if d.new_file.path == 'path.txt'].pop() == [
+        assert [d.to_dict(deltacode_object).get('new').get('licenses') for d in deltas_object if d.new_file.path == 'path.txt'].pop() == [
             OrderedDict([
                 ('key', 'mit'),
                 ('score', 95.0),