Merge pull request #633 from gilsonsouza/master

fate#324198: filter modules extensions based on product

package/yast2-installation.changes

@@ -1,3 +1,10 @@
+-------------------------------------------------------------------
+Fri Dec  8 14:17:28 UTC 2017 - gsouza@suse.com
+
+- Filter out modules extensions based on product, using white list
+  approach (fate##324198)
+- 4.0.16
+
 -------------------------------------------------------------------
 Mon Dec  4 12:32:49 UTC 2017 - igonzalezsosa@suse.com
 

package/yast2-installation.spec

@@ -16,7 +16,7 @@
 #
 
 Name:           yast2-installation
-Version:        4.0.15
+Version:        4.0.16
 Release:        0
 
 BuildRoot:      %{_tmppath}/%{name}-%{version}-build

src/lib/installation/clients/inst_modules_extensions.rb

@@ -1,4 +1,5 @@
 require "yast"
+require "y2packager/product"
 
 Yast.import "GetInstArgs"
 Yast.import "Pkg"
@@ -21,15 +22,34 @@ def run
     private
 
       PROVIDES_KEY = "installer_module_extension()".freeze
+      PROVIDES_PRODUCT = "extension_for_product()".freeze
 
       def extension_packages
+        product = Y2Packager::Product.selected_base
         extension_packages = Yast::Pkg.PkgQueryProvides(PROVIDES_KEY)
         log.info "module extension packages #{extension_packages.inspect}"
+        dependencies = {}
+
+        extension_packages.select! do |list|
+          pkg_name = list.first
+          dependencies[pkg_name] = Yast::Pkg.ResolvableDependencies(pkg_name, :package, "").first["deps"]
+
+          product_provides = dependencies[pkg_name].find_all do |d|
+            d["provides"] && d["provides"].match(/#{Regexp.escape(PROVIDES_PRODUCT)}/)
+          end
+          log.info "package #{pkg_name} contains the following product provides #{product_provides}"
+
+          target_product = product_provides.any? do |d|
+            d["provides"][/#{Regexp.escape(PROVIDES_PRODUCT)}\s*=\s*(\S+)/, 1] == product.name
+          end
+
+          # If no product is specified for the role, it should be available to all products
+          product_provides.empty? || target_product
+        end
 
         extension_packages.map do |list|
           pkg_name = list.first
-          dependencies = Yast::Pkg.ResolvableDependencies(pkg_name, :package, "").first["deps"]
-          extension_provide = dependencies.find do |d|
+          extension_provide = dependencies[pkg_name].find do |d|
             d["provides"] && d["provides"].match(/#{Regexp.escape(PROVIDES_KEY)}/)
           end
 

test/lib/inst_modules_extensions_test.rb

@@ -5,16 +5,22 @@
 
 describe ::Installation::Clients::InstModulesExtensions do
   describe "#run" do
+    let(:deps_package_a) { [{ "deps" => [{ "provides" => "installer_module_extension() = module_a" }] }] }
+    let(:deps_package_b) { [{ "deps" => [{ "provides" => "installer_module_extension() = module_b" }] }] }
+    let(:product) { Y2Packager::Product.new(name: "SLES") }
+
     before do
       allow(Yast::Pkg).to receive(:PkgQueryProvides).and_return([["package_a"], ["package_b"]])
 
       allow(Yast::Pkg).to receive(:ResolvableDependencies).with("package_a", :package, "")
-        .and_return([{ "deps" => [{ "provides" => "installer_module_extension() = module_a" }] }])
+        .and_return(deps_package_a)
 
       allow(Yast::Pkg).to receive(:ResolvableDependencies).with("package_b", :package, "")
-        .and_return([{ "deps" => [{ "provides" => "installer_module_extension() = module_b" }] }])
+        .and_return(deps_package_b)
 
       allow(Yast::WorkflowManager).to receive(:merge_modules_extensions)
+
+      allow(Y2Packager::Product).to receive(:selected_base) .and_return(product)
     end
 
     it "returns :back if going back" do
@@ -27,10 +33,78 @@
       expect(subject.run).to eq :next
     end
 
-    it "merges installation workflow for module extension packages" do
-      expect(Yast::WorkflowManager).to receive(:merge_modules_extensions).with(["package_a", "package_b"])
+    context "when no product is specified in roles" do
+      it "merges installation workflow for all module extension packages" do
+        expect(Yast::WorkflowManager).to receive(:merge_modules_extensions).with(["package_a", "package_b"])
+
+        subject.run
+      end
+    end
+
+    context "when all roles are specified for a different product" do
+      let(:deps_package_a) do
+        [{ "deps" => [{ "provides" => "installer_module_extension() = module_b" },
+                      { "provides" => "extension_for_product() = SLED" }] }]
+      end
+      let(:deps_package_b) do
+        [{ "deps" => [{ "provides" => "installer_module_extension() = module_a" },
+                      { "provides" => "extension_for_product() = SLED" }] }]
+      end
+
+      it "does not merge installation workflow for the module extension packages" do
+        expect(Yast::WorkflowManager).to receive(:merge_modules_extensions).with([])
+
+        subject.run
+      end
+    end
+
+    context "when only one role is specified for a different product" do
+      let(:deps_package_a) do
+        [{ "deps" => [{ "provides" => "installer_module_extension() = module_b" },
+                      { "provides" => "extension_for_product() = SLED" }] }]
+      end
+
+      it "merges installation workflow for the other module extension packages" do
+        expect(Yast::WorkflowManager).to receive(:merge_modules_extensions).with(["package_b"])
+
+        subject.run
+      end
+    end
+
+    context "when all roles are specified only for the current product" do
+      let(:deps_package_a) do
+        [{ "deps" => [{ "provides" => "installer_module_extension() = module_b" },
+                      { "provides" => "extension_for_product() = SLES" }] }]
+      end
+      let(:deps_package_b) do
+        [{ "deps" => [{ "provides" => "installer_module_extension() = module_a" },
+                      { "provides" => "extension_for_product() = SLES" }] }]
+      end
+
+      it "merges installation workflow for all module extension packages" do
+        expect(Yast::WorkflowManager).to receive(:merge_modules_extensions).with(["package_a", "package_b"])
+
+        subject.run
+      end
+    end
+
+    context "when all roles are specified for multiple products, including the current one" do
+      let(:deps_package_a) do
+        [{ "deps" => [{ "provides" => "installer_module_extension() = module_b" },
+                      { "provides" => "extension_for_product() = SLES" },
+                      { "provides" => "extension_for_product() = SLED" }] }]
+      end
+      let(:deps_package_b) do
+        [{ "deps" => [{ "provides" => "installer_module_extension() = module_a" },
+                      { "provides" => "extension_for_product() = SLED" },
+                      { "provides" => "extension_for_product() = SLES" }] }]
+      end
+
+      it "merges installation workflow for all module extension packages" do
+        expect(Yast::WorkflowManager).to receive(:merge_modules_extensions).with(["package_a", "package_b"])
 
-      subject.run
+        subject.run
+      end
     end
   end
 end