added implementation's first iteration

Author: ash2shukla

core/dbt/config/project.py

@@ -18,6 +18,7 @@
 from dbt.constants import (
     DBT_PROJECT_FILE_NAME,
     DEPENDENCIES_FILE_NAME,
+    PACKAGE_LOCK_FILE_NAME,
     PACKAGE_LOCK_HASH_KEY,
     PACKAGES_FILE_NAME,
 )
@@ -152,6 +153,11 @@ def package_config_from_data(
     return packages
 
 
+def load_package_lock_config(project_root: str) -> PackageConfig:
+    locked_packages = load_yml_dict(f"{project_root}/{PACKAGE_LOCK_FILE_NAME}")
+    return PackageConfig.from_dict(locked_packages)
+
+
 def _parse_versions(versions: Union[List[str], str]) -> List[VersionSpecifier]:
     """Parse multiple versions as read from disk. The versions value may be any
     one of:

core/dbt/config/runtime.py

@@ -24,7 +24,7 @@
 from dbt.adapters.contracts.relation import ComponentName
 from dbt.adapters.factory import get_include_paths, get_relation_class_by_name
 from dbt.artifacts.resources import Quoting
-from dbt.config.project import load_raw_project
+from dbt.config.project import load_package_lock_config, load_raw_project
 from dbt.contracts.graph.manifest import ManifestMetadata
 from dbt.contracts.project import Configuration
 from dbt.events.types import UnusedResourceConfigPath
@@ -400,13 +400,15 @@ def load_dependencies(self, base_only=False) -> Mapping[str, "RuntimeConfig"]:
                 # Test setup -- we want to load macros without dependencies
                 project_paths = itertools.chain(internal_packages)
             else:
-                # raise exception if fewer installed packages than in packages.yml
-                count_packages_specified = len(self.packages.packages)  # type: ignore
-                count_packages_installed = len(tuple(self._get_project_directories()))
-                if count_packages_specified > count_packages_installed:
+                locked_packages = load_package_lock_config(self.project_root)
+                expected_packages_names = {p.name for p in locked_packages.packages if p.name is not None}  # type: ignore
+                installed_packages = {p.stem for p in self._get_project_directories()}
+
+                uninstalled_packages = expected_packages_names - installed_packages
+
+                if uninstalled_packages:
                     raise UninstalledPackagesFoundError(
-                        count_packages_specified,
-                        count_packages_installed,
+                        list(uninstalled_packages),
                         self.packages_specified_path,
                         self.packages_install_path,
                     )

core/dbt/exceptions.py

@@ -1073,23 +1073,21 @@ def get_message(self) -> str:
 class UninstalledPackagesFoundError(CompilationError):
     def __init__(
         self,
-        count_packages_specified: int,
-        count_packages_installed: int,
+        uninstalled_packages: List[str],
         packages_specified_path: str,
         packages_install_path: str,
     ):
-        self.count_packages_specified = count_packages_specified
-        self.count_packages_installed = count_packages_installed
+        self.uninstalled_packages = uninstalled_packages
         self.packages_specified_path = packages_specified_path
         self.packages_install_path = packages_install_path
         super().__init__(msg=self.get_message())
 
     def get_message(self) -> str:
+        uninstalled_packages_str = ", ".join(self.uninstalled_packages)
         msg = (
-            f"dbt found {self.count_packages_specified} package(s) "
-            f"specified in {self.packages_specified_path}, but only "
-            f"{self.count_packages_installed} package(s) installed "
-            f'in {self.packages_install_path}. Run "dbt deps" to '
+            f"dbt could not find following packages: {uninstalled_packages_str}. "
+            f"Packages are specified in {self.packages_specified_path}, "
+            f'and installed in {self.packages_install_path}. Run "dbt deps" to '
             "install package dependencies."
         )
         return msg