fix in test cli

Signed-off-by: Pratik Dey <pratikrocks.dey11@gmail.com>

Author: pratik0316

src/deltacode/__init__.py

@@ -28,12 +28,12 @@
 import os
 from collections import OrderedDict
 
-from deltacode.models import File
-from deltacode.models import Scan
 from deltacode import utils
+from deltacode.exceptions import FileError as FileError
 from commoncode import paths
 from commoncode.resource import VirtualCodebase
 
+
 from pkg_resources import get_distribution, DistributionNotFound
 
 try:
@@ -59,29 +59,31 @@ def __init__(self, new_path, old_path, options):
         self.deltas = []
         self.errors = []
 
-        try:
+        if os.path.isfile(new_path) and os.path.isfile(old_path):
             self.codebase1 = VirtualCodebase(new_path)
             self.codebase2 = VirtualCodebase(old_path)
 
-        except Exception as exception:
-            print(str(exception))
-            self.errors.append(str(exception))
-
-        if self.codebase1 is not None or self.codebase2 is not None:
-            self.stats = Stat(
-                self.codebase1.compute_counts(), self.codebase2.compute_counts()
+        else:
+            error_message = (
+                "{} is expected to be a file".format(new_path)
+                if not os.path.isfile(new_path)
+                else "{} is expected to be a file".format(old_path)
             )
-            self.new_files_errors = []
-            self.old_files_errors = []
-            self.determine_delta()
-            self.license_diff()
-            self.copyright_diff()
-            self.stats.calculate_stats()
-            self.similarity()
-            # Sort deltas by score, descending, i.e., high > low, and then by
-            # factors, alphabetically.  Run the least significant sort first.
-            self.deltas.sort(key=lambda Delta: Delta.factors, reverse=False)
-            self.deltas.sort(key=lambda Delta: Delta.score, reverse=True)
+            raise FileError(error_message)
+        self.stats = Stat(
+            self.codebase1.compute_counts(), self.codebase2.compute_counts()
+        )
+        self.new_files_errors = []
+        self.old_files_errors = []
+        self.determine_delta()
+        self.license_diff()
+        self.copyright_diff()
+        self.stats.calculate_stats()
+        self.similarity()
+        # Sort deltas by score, descending, i.e., high > low, and then by
+        # factors, alphabetically.  Run the least significant sort first.
+        self.deltas.sort(key=lambda Delta: Delta.factors, reverse=False)
+        self.deltas.sort(key=lambda Delta: Delta.score, reverse=True)
 
     def similarity(self):
         """
@@ -94,18 +96,22 @@ def similarity(self):
         for delta in self.deltas:
             if delta.new_file == None or delta.old_file == None:
                 continue
-            new_fingerprint = delta.new_file.fingerprint if hasattr(delta.new_file, "fingerprint") else None
-            old_fingerprint = delta.old_file.fingerprint if hasattr(delta.old_file, "fingerprint") else None
-
-            if new_fingerprint == None or old_fingerprint == None:
-                continue
-            new_fingerprint = utils.bitarray_from_hex(
+            new_fingerprint = (
                 delta.new_file.fingerprint
+                if hasattr(delta.new_file, "fingerprint")
+                else None
             )
-            old_fingerprint = utils.bitarray_from_hex(
+            old_fingerprint = (
                 delta.old_file.fingerprint
+                if hasattr(delta.old_file, "fingerprint")
+                else None
             )
 
+            if new_fingerprint == None or old_fingerprint == None:
+                continue
+            new_fingerprint = utils.bitarray_from_hex(delta.new_file.fingerprint)
+            old_fingerprint = utils.bitarray_from_hex(delta.old_file.fingerprint)
+
             hamming_distance = utils.hamming_distance(new_fingerprint, old_fingerprint)
             if hamming_distance > 0 and hamming_distance <= SIMILARITY_LIMIT:
                 delta.score += hamming_distance
@@ -127,7 +133,7 @@ def determine_delta(self):
         from either scan.
         """
 
-        old_files_sha1_considered_in_deltas = dict()
+        old_resource_considered = dict()
         try:
             Delta.NEW_CODEBASE_OFFSET, Delta.OLD_CODEBASE_OFFSET = utils.align_trees(
                 self.codebase1, self.codebase2
@@ -140,22 +146,37 @@ def determine_delta(self):
                 path_new = "/".join(
                     paths.split(new_resource.path)[Delta.NEW_CODEBASE_OFFSET :]
                 )
+
+                old_resource = self.codebase2.get_resource_from_path(path_new)
+
+                if old_resource and old_resource.sha1 == new_resource.sha1:
+                    old_resource_considered[old_resource.path] = 1
+                    path_old = "/".join(
+                        paths.split(old_resource.path)[Delta.OLD_CODEBASE_OFFSET :]
+                    )
+                    self.create_deltas(
+                        new_resource, old_resource, path_new, path_old, 0, "unmodified",
+                    )
+                    self.stats.num_unmodified += 1
+
+                    continue
+
                 ADDED = True
                 for old_resource in self.codebase2.walk():
+                    if old_resource.path in old_resource_considered.keys():
+                        continue
+                    path_old = "/".join(
+                        paths.split(old_resource.path)[Delta.OLD_CODEBASE_OFFSET :]
+                    )
                     if (
                         old_resource.is_file
-                        and not old_resource.sha1
-                        in old_files_sha1_considered_in_deltas.keys()
+                        and not old_resource.path in old_resource_considered.keys()
                     ):
-                        path_old = "/".join(
-                            paths.split(old_resource.path)[Delta.OLD_CODEBASE_OFFSET :]
-                        )
+
                         if path_new == path_old:
                             ADDED = False
                             if new_resource.sha1 == old_resource.sha1:
-                                old_files_sha1_considered_in_deltas[
-                                    old_resource.sha1
-                                ] = 1
+                                old_resource_considered[old_resource.path] = 1
                                 self.create_deltas(
                                     new_resource,
                                     old_resource,
@@ -167,9 +188,7 @@ def determine_delta(self):
                                 self.stats.num_unmodified += 1
                                 break
                             else:
-                                old_files_sha1_considered_in_deltas[
-                                    old_resource.sha1
-                                ] = 1
+                                old_resource_considered[old_resource.path] = 1
                                 self.create_deltas(
                                     new_resource,
                                     old_resource,
@@ -182,9 +201,7 @@ def determine_delta(self):
                                 break
                         else:
                             if new_resource.sha1 == old_resource.sha1:
-                                old_files_sha1_considered_in_deltas[
-                                    old_resource.sha1
-                                ] = 1
+                                old_resource_considered[old_resource.path] = 1
                                 ADDED = False
                                 self.create_deltas(
                                     new_resource,
@@ -199,33 +216,22 @@ def determine_delta(self):
 
                 if ADDED:
                     self.create_deltas(
-                        new_resource,
-                        None,
-                        path_new,
-                        None,
-                        100,
-                        "added",
+                        new_resource, None, path_new, None, 100, "added",
                     )
                     self.stats.num_added += 1
 
         for old_resource_remaining in self.codebase2.walk():
             if (
                 old_resource_remaining.is_file
-                and old_resource_remaining.sha1
-                not in old_files_sha1_considered_in_deltas.keys()
+                and old_resource_remaining.path not in old_resource_considered.keys()
             ):
                 path_old = "/".join(
                     paths.split(old_resource_remaining.path)[
                         Delta.OLD_CODEBASE_OFFSET :
                     ]
                 )
                 self.create_deltas(
-                    None,
-                    old_resource_remaining,
-                    None,
-                    path_old,
-                    0,
-                    "removed",
+                    None, old_resource_remaining, None, path_old, 0, "removed",
                 )
                 self.stats.num_removed += 1
 
@@ -368,7 +374,7 @@ def licenses_to_dict(self, file):
             return []
 
     def file_to_dict(self, deltacode, file, new_file=True):
-        
+
         path_offset = (
             Delta.NEW_CODEBASE_OFFSET if new_file else Delta.OLD_CODEBASE_OFFSET
         )
@@ -380,7 +386,10 @@ def file_to_dict(self, deltacode, file, new_file=True):
                     ("name", file.name),
                     ("size", file.size),
                     ("sha1", file.sha1),
-                    ("fingerprint", file.fingerprint if hasattr(file, "fingerprint") else ""),
+                    (
+                        "fingerprint",
+                        file.fingerprint if hasattr(file, "fingerprint") else "",
+                    ),
                     ("original_path", file.path),
                     ("licenses", self.licenses_to_dict(file)),
                     ("copyrights", self.copyrights_to_dict(file)),
@@ -392,7 +401,10 @@ def to_dict(self, deltacode):
         Return an OrderedDict comprising the 'factors', 'score' and new and old
         'path' attributes of the object.
         """
-        if not deltacode.options.get("--all-delta-types", "") == True and self.status == "unmodified":
+        if (
+            not deltacode.options.get("--all-delta-types", "") == True
+            and self.status == "unmodified"
+        ):
             return
         if self.new_file:
             new_file = self.new_file.to_dict()

src/deltacode/exceptions.py

@@ -0,0 +1,35 @@
+#
+# Copyright (c) 2017-2018 nexB Inc. and others. All rights reserved.
+# http://nexb.com and https://github.com/nexB/deltacode/
+# The DeltaCode software is licensed under the Apache License version 2.0.
+# Data generated with DeltaCode require an acknowledgment.
+# DeltaCode is a trademark of nexB Inc.
+#
+# You may not use this software except in compliance with the License.
+# You may obtain a copy of the License at: http://apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+#
+# When you publish or redistribute any data created with DeltaCode or any DeltaCode
+# derivative work, you must accompany this data with the following acknowledgment:
+#
+#  Generated with DeltaCode and provided on an "AS IS" BASIS, WITHOUT WARRANTIES
+#  OR CONDITIONS OF ANY KIND, either express or implied. No content created from
+#  DeltaCode should be considered or used as legal advice. Consult an Attorney
+#  for any legal advice.
+#  DeltaCode is a free and open source software analysis tool from nexB Inc. and others.
+#  Visit https://github.com/nexB/deltacode/ for support and download.
+#
+
+
+class FileError(Exception):
+    def __init__(self, *args):
+        if args:
+            self.message = args[0]
+        else:
+            self.message = None
+
+    def __str__(self):
+        return self.message

tests/data/deltacode/coala-expected-result.json

@@ -1,5 +1,11 @@
 {
   "deltacode_notice": "Generated with DeltaCode and provided on an \"AS IS\" BASIS, WITHOUT WARRANTIES\nOR CONDITIONS OF ANY KIND, either express or implied. No content created from\nDeltaCode should be considered or used as legal advice. Consult an Attorney\nfor any legal advice.\nDeltaCode is a free software codebase-comparison tool from nexB Inc. and others.\nVisit https://github.com/nexB/deltacode/ for support and download.",
+  "deltacode_options": {
+    "--new": "tests/data/deltacode/coala-0.10.0-new.json",
+    "--old": "tests/data/deltacode/coala-0.7.0-old.json",
+    "--all-delta-types": true
+  },
+  "deltacode_version": "1.0.1.dev112+gde3c583.d20210613",
   "deltacode_errors": [],
   "deltas_count": 141,
   "delta_stats": {
@@ -2988,6 +2994,33 @@
         "copyrights": []
       }
     },
+    {
+      "status": "moved",
+      "factors": [],
+      "score": 0,
+      "new": {
+        "path": "coalib/testing/__init__.py",
+        "type": "file",
+        "name": "__init__.py",
+        "size": 0,
+        "sha1": null,
+        "fingerprint": null,
+        "original_path": "coalib/testing/__init__.py",
+        "licenses": [],
+        "copyrights": []
+      },
+      "old": {
+        "path": "coalib/bears/requirements/__init__.py",
+        "type": "file",
+        "name": "__init__.py",
+        "size": 0,
+        "sha1": null,
+        "fingerprint": null,
+        "original_path": "coalib/bears/requirements/__init__.py",
+        "licenses": [],
+        "copyrights": []
+      }
+    },
     {
       "status": "removed",
       "factors": [],
@@ -3395,33 +3428,6 @@
         "licenses": [],
         "copyrights": []
       }
-    },
-    {
-      "status": "moved",
-      "factors": [],
-      "score": 0,
-      "new": {
-        "path": "coalib/testing/__init__.py",
-        "type": "file",
-        "name": "__init__.py",
-        "size": 0,
-        "sha1": null,
-        "fingerprint": null,
-        "original_path": "coalib/testing/__init__.py",
-        "licenses": [],
-        "copyrights": []
-      },
-      "old": {
-        "path": "coalib/bears/requirements/__init__.py",
-        "type": "file",
-        "name": "__init__.py",
-        "size": 0,
-        "sha1": null,
-        "fingerprint": null,
-        "original_path": "coalib/bears/requirements/__init__.py",
-        "licenses": [],
-        "copyrights": []
-      }
     }
   ]
 }

tests/data/deltacode/delta_to_dict_added_new.json

@@ -0,0 +1,29 @@
+{
+    "scancode_notice": "Generated with ScanCode and provided on an \"AS IS\" BASIS, WITHOUT WARRANTIES\nOR CONDITIONS OF ANY KIND, either express or implied. No content created from\nScanCode should be considered or used as legal advice. Consult an Attorney\nfor any legal advice.\nScanCode is a free software code scanning tool from nexB Inc. and others.\nVisit https://github.com/nexB/scancode-toolkit/ for support and download.",
+    "scancode_version": "2.1.0",
+    "scancode_options": {
+        "--license": true,
+        "--info": true
+    },
+    "files_count": 2,
+    "files": [
+        {
+            "path": "path",
+            "type": "directory",
+            "name": "path",
+            "size": 20,
+            "sha1": "a",
+            "fingerprint": "e30cf09456e7878dfed3288886e97542",
+            "original_path": ""
+        },
+        {
+            "path": "path/added.txt",
+            "type": "file",
+            "name": "added.txt",
+            "size": 20,
+            "sha1": "a",
+            "fingerprint": "e30cf09443e7878dfed3288886e12345",
+            "original_path": ""
+        }
+    ]
+}