Sorted addons below product base (part of bsc#992304) (#180)

* Sorted addons properly below product base.

* Changelog and version updated.

package/yast2-packager.changes

@@ -1,3 +1,10 @@
+-------------------------------------------------------------------
+Wed Aug 10 16:39:10 UTC 2016 - kanderssen@suse.com
+
+- List addons below base product in Software proposal during
+  installation. (bsc#992304)
+- 3.1.110
+
 -------------------------------------------------------------------
 Thu Jul 28 10:40:32 UTC 2016 - jreidinger@suse.com
 

package/yast2-packager.spec

@@ -17,7 +17,7 @@
 
 
 Name:           yast2-packager
-Version:        3.1.109
+Version:        3.1.110
 Release:        0
 
 BuildRoot:      %{_tmppath}/%{name}-%{version}-build

src/modules/Packages.rb

@@ -16,6 +16,10 @@ class PackagesClass < Module
 
     # All known types of resolvables
     RESOLVABLE_TYPES = [:product, :patch, :package, :pattern, :language]
+
+    # Key to sort by resolvable selection
+    RESOLVABLE_SORT_ORDER = { :product => "source", :pattern => "order" }
+
     # Minimum set of packages tags required to enable VNC server
     VNC_BASE_TAGS = ["xorg-x11", "xorg-x11-Xvnc", "xorg-x11-fonts", "xinetd"]
     # Additional packages tags needed to run second stage in graphical mode
@@ -157,40 +161,15 @@ def ResetProposalCache
     # @param [String] format string format string to print summaries in
     # @return a list of selected resolvables
     def ListSelected(what, format)
-      format = "%1" if format == "" || format == nil
       selected = Pkg.ResolvableProperties("", what, "")
 
-      # ignore hidden patterns
-      if what == :pattern
-        selected = Builtins.filter(selected) do |r|
-          Ops.get(r, "user_visible") == true
-        end
+      selected.select! {|r| r["status"] == :selected }
 
-        # order patterns according to "order" flag
-        selected = Builtins.sort(selected) do |x, y|
-          xo = Builtins.tointeger(Ops.get_string(x, "order", ""))
-          yo = Builtins.tointeger(Ops.get_string(y, "order", ""))
-          if xo == nil || yo == nil
-            # order is not an integer, compare as strings
-            next Ops.less_than(
-              Ops.get_string(x, "order", ""),
-              Ops.get_string(y, "order", "")
-            )
-          else
-            next Ops.less_than(xo, yo)
-          end
-        end
-      end
+      selected.select! {|r| r["user_visible"] } if what == :pattern
 
-      selected = Builtins.filter(selected) do |r|
-        Ops.get(r, "status") == :selected
-      end
+      sort_resolvable!(selected, what)
 
-      ret = Builtins.maplist(selected) do |r|
-        disp = Ops.get_string(r, "summary", Ops.get_string(r, "name", ""))
-        Builtins.sformat(format, disp)
-      end
-      deep_copy(ret)
+      formatted_resolvables(selected, format)
     end
 
     # Count the total size of packages to be installed
@@ -2599,6 +2578,33 @@ def log_resolvables(text, resolvables)
       end
     end
 
+    # Prepares a list of formatted selected resolvables
+    #
+    # @param [Array<Hash>] list of selected resolvables to format
+    # @param [String] string format to use
+    def formatted_resolvables(selected, format)
+      format = "%1" if format == "" || format == nil
+
+      Builtins.maplist(selected) do |r|
+        disp = Ops.get_string(r, "summary", Ops.get_string(r, "name", ""))
+        Builtins.sformat(format, disp)
+      end
+    end
+
+    # Sort selected resolvables of specified type
+    #
+    # :pattern resolvables are sorted by "order"
+    # :product resolvables are sorted by "source"
+    #
+    # @param [Array<Hash>] list of selected resolvables to sort
+    # @param [Symbol] what symbol specifying the type of resolvables to select
+    # @see RESOLVABLE_SORT_ORDER
+    def sort_resolvable!(selected, what)
+      order = RESOLVABLE_SORT_ORDER[what]
+
+      selected.sort_by! { |r| r[order].to_i } if order
+    end
+
     # Computes all patterns that are expected to be selected for default installation
     def patterns_to_install
       patterns = ComputeSystemPatternList().dup

test/packages_test.rb

@@ -897,4 +897,92 @@ def product(properties = {})
       Yast::Packages.Reset([:product])
     end
   end
+
+  describe "#ListSelected" do
+    let(:unordered_products) do
+      [
+        product("name" => "p3", "status" => :selected, "source" => 15),
+        product("name" => "p4", "status" => :available, "source" => 40),
+        product("name" => "p1", "status" => :selected, "source" => 10)
+      ]
+    end
+
+    let(:filtered_products) do
+      [
+        product("name" => "p3", "status" => :selected, "source" => 15),
+        product("name" => "p1", "status" => :selected, "source" => 10)
+      ]
+    end
+
+    let(:ordered_products) do
+      [
+        product("name" => "p1", "status" => :selected, "source" => 10),
+        product("name" => "p3", "status" => :selected, "source" => 15)
+      ]
+    end
+
+    let(:unordered_patterns) do
+      [
+        pattern("name" => "p3", "status" => :selected, "order" => "3", "user_visible" => true),
+        pattern("name" => "p1", "status" => :selected, "order" => "1", "user_visible" => false),
+        pattern("name" => "p2", "status" => :available, "order" => "2", "user_visible" => true)
+      ]
+    end
+
+    let(:filtered_patterns) do
+      [
+        pattern("name" => "p3", "status" => :selected, "order" => "3", "user_visible" => true)
+      ]
+    end
+
+    before do
+      allow(Yast::Pkg).to receive(:ResolvableProperties).with("", :product, "")
+        .and_return(unordered_products)
+    end
+
+    it "obtains a list of resolvables of the given type" do
+      expect(Yast::Pkg).to receive(:ResolvableProperties).with("", :product, "")
+
+      subject.ListSelected(:product, "")
+    end
+
+    it "filters not selected resolvables from the list" do
+      expect(subject).to receive(:sort_resolvable!)
+        .with(filtered_products, :product)
+
+      subject.ListSelected(:product, "")
+    end
+
+    it "filters not user visible resolvables from the list for type pattern" do
+      expect(Yast::Pkg).to receive(:ResolvableProperties).with("", :pattern, "")
+        .and_return(unordered_patterns)
+      expect(subject).to receive(:sort_resolvable!)
+        .with(filtered_patterns, :pattern)
+
+      subject.ListSelected(:pattern, "")
+    end
+
+    it "sorts resultant list depending on resolvable type" do
+      expect(subject).to receive(:formatted_resolvables).with(ordered_products, "")
+
+      subject.ListSelected(:product, "")
+    end
+
+    it "returns an empty list if no resolvables selected" do
+      allow(Yast::Pkg).to receive(:ResolvableProperties).with("", :product, "")
+        .and_return([])
+
+      expect(subject.ListSelected(:product, "Product: %1")).to eql([])
+    end
+
+    it "returns a list with each resultant resolvable formatted as the format given" do
+      expect(subject.ListSelected(:product, "Product: %1")).to eql(
+        [
+          "Product: p1",
+          "Product: p3"
+        ]
+      )
+    end
+  end
+
 end