Adapt to the Y2Packager::ProductSpec API

src/lib/y2packager/clients/inst_repositories_initialization.rb

@@ -110,7 +110,7 @@ def init_installation_repositories
       # @see Yast::WorkflowManager.merge_product_workflow
       def merge_and_run_workflow
         Yast::WorkflowManager.SetBaseWorkflow(false)
-        Yast::WorkflowManager.merge_product_workflow(Y2Packager::Product.selected_base)
+        Yast::WorkflowManager.merge_product_workflow(Y2Packager::ProductSpec.selected_base.to_product)
         Yast::ProductControl.RunFrom(Yast::ProductControl.CurrentStep + 1, true)
       end
 
@@ -127,7 +127,7 @@ def merge_and_run_workflow
       # @see https://github.com/yast/yast-packager/blob/7e1a0bbb90823b03c15d92f408036a560dca8aa3/src/modules/Packages.rb#L1876
       # @see https://github.com/yast/yast-packager/blob/fbc396df910e297915f9f785fc460e72e30d1948/src/modules/Packages.rb#L1905
       def adjust_base_product_selection
-        forced_base_product = Y2Packager::Product.forced_base_product
+        forced_base_product = Y2Packager::ProductSpec.forced_base_product&.to_product
 
         if forced_base_product
           log.info("control.xml wants to force the #{forced_base_product.name} product")
@@ -145,9 +145,9 @@ def adjust_base_product_selection
 
       # Return base available products
       #
-      # @return [Array<Y2Product>] Available base products
+      # @return [Array<Y2Packager::ProductSpec>] Available base products
       def products
-        @products ||= Y2Packager::Product.available_base_products
+        @products ||= Y2Packager::ProductSpec.base_products.map(&:to_product)
       end
     end
   end

src/lib/y2packager/medium_type.rb

@@ -14,6 +14,7 @@
 
 require "y2packager/product_location"
 require "y2packager/repomd_downloader"
+require "y2packager/product_spec_readers/full"
 
 Yast.import "InstURL"
 
@@ -126,8 +127,9 @@ def detect_medium_type
         base_product = nil
         # run the scan even when there is only one repository on the medium
         force_scan = true
-        base_products = Y2Packager::ProductLocation.scan(url, base_product, force_scan)
-          .select { |p| p.details&.base }
+        base_products = Y2Packager::ProductSpecReaders::Full.new
+          .products(url, base_product, force_scan)
+          .select(&:base)
 
         if base_products.empty?
           log.info("Detected medium type: online (no base product found on the medium)")

src/lib/y2packager/product_finder.rb

@@ -50,8 +50,7 @@ def products(selected_base, media_names)
         # a product was found in this directory?
         next if ret.any? { |p| p.dir == dir }
 
-        # FIXME: it won't work
-        ret << RepoProductSpec.new(name: name, dir: dir)
+        ret << RepoProductSpec.new(name: name, dir: dir, base: false)
       end
 
       ret

src/lib/y2packager/repo_product_spec.rb

@@ -20,6 +20,7 @@
 require "yast"
 require "y2packager/product_spec"
 
+Yast.import "Arch"
 Yast.import "Packages"
 Yast.import "InstURL"
 Yast.import "Pkg"
@@ -46,14 +47,20 @@ class RepoProductSpec < ProductSpec
     # @return [String,nil] Product description
     attr_reader :description
 
-    def initialize(name:, version:, arch:, display_name:, order:, base:, depends_on:, dir:,
-      media_name:, description:)
-      super(name: name, version: version, display_name: display_name, arch: arch,
-            order: order, base: base)
+    def initialize(name:, version: nil, arch: nil, display_name: "", order: nil, base: true,
+      depends_on: [], dir:, media_name: nil, description: nil)
+      super(
+        name: name,
+        version: version,
+        display_name: display_name,
+        arch: arch || Yast::Arch.architecture,
+        order: order,
+        base: base
+      )
 
       @depends_on = depends_on
       @dir = dir
-      @media_name = media_name
+      @media_name = media_name || dir
       @description = description
     end
 

test/lib/clients/inst_repositories_initialization_test.rb

@@ -7,17 +7,19 @@
   subject(:client) { described_class.new }
 
   let(:success) { true }
+  let(:prod1_spec) { instance_double(Y2Packager::ProductSpec, name: "Prod1", to_product: prod1) }
+  let(:prod2_spec) { instance_double(Y2Packager::ProductSpec, name: "Prod2", to_product: prod2) }
   let(:prod1) { instance_double(Y2Packager::Product, name: "Prod1", select: nil) }
   let(:prod2) { instance_double(Y2Packager::Product, name: "Prod2", select: nil) }
-  let(:products) { [prod1] }
+  let(:products) { [prod1_spec] }
 
   describe "#main" do
     before do
       allow(Yast::Packages).to receive(:InitializeCatalogs)
       allow(Yast::Packages).to receive(:InitializeAddOnProducts)
       allow(Yast::Packages).to receive(:InitFailed).and_return(!success)
-      allow(Y2Packager::Product).to receive(:forced_base_product)
-      allow(Y2Packager::Product).to receive(:available_base_products).and_return(products)
+      allow(Y2Packager::ProductSpec).to receive(:forced_base_product)
+      allow(Y2Packager::ProductSpec).to receive(:base_products).and_return(products)
       allow(Y2Packager::SelfUpdateAddonRepo).to receive(:present?).and_return(false)
       allow(Y2Packager::MediumType).to receive(:online?).and_return(false)
       allow(Y2Packager::MediumType).to receive(:offline?).and_return(false)
@@ -74,7 +76,7 @@
     end
 
     context "when only one product is available" do
-      let(:products) { [prod1] }
+      let(:products) { [prod1_spec] }
 
       it "selects the product for installation" do
         expect(prod1).to receive(:select)
@@ -83,10 +85,10 @@
     end
 
     context "when a product is forced to be used" do
-      let(:products) { [prod1, prod2] }
+      let(:products) { [prod1_spec, prod2_spec] }
 
       before do
-        allow(Y2Packager::Product).to receive(:forced_base_product).and_return(prod2)
+        allow(Y2Packager::ProductSpec).to receive(:forced_base_product).and_return(prod2_spec)
       end
 
       it "selects the product for installation" do
@@ -96,7 +98,7 @@
     end
 
     context "when more than one product is available" do
-      let(:products) { [prod1, prod2] }
+      let(:products) { [prod1_spec, prod2_spec] }
 
       it "unselects all products" do
         expect(prod1).to receive(:restore)

test/lib/repo_product_spec_test.rb

@@ -30,6 +30,24 @@
     )
   end
 
+  describe ".new" do
+    before do
+      allow(Yast::Arch).to receive(:architecture).and_return("x86_64")
+    end
+
+    context "when only name and dir are specified" do
+      it "sets default values" do
+        product_spec = described_class.new(name: "SLES", dir: "/SLES")
+        expect(product_spec.name).to eq("SLES")
+        expect(product_spec.dir).to eq("/SLES")
+        expect(product_spec.media_name).to eq("/SLES")
+        expect(product_spec.arch).to eq("x86_64")
+        expect(product_spec.version).to be_nil
+        expect(product_spec.order).to be_nil
+      end
+    end
+  end
+
   describe "#select" do
     let(:product) { instance_double(Y2Packager::Product, select: nil) }
     let(:url) { "http://example.com" }

test/medium_type_test.rb

@@ -14,6 +14,12 @@
   end
 
   describe "#type" do
+    let(:reader) { instance_double(Y2Packager::ProductSpecReaders::Full) }
+
+    before do
+      allow(Y2Packager::ProductSpecReaders::Full).to receive(:new).and_return(reader)
+    end
+
     it "raises an exception when the installation URL is nil" do
       expect(Yast::InstURL).to receive(:installInf2Url).and_return(nil)
       expect { described_class.type }.to raise_exception(/The installation URL is not set/)
@@ -43,7 +49,7 @@
       end
 
       it "returns :online if the repository does not contain any base product" do
-        expect(Y2Packager::ProductLocation).to receive(:scan).and_return([])
+        expect(reader).to receive(:products).and_return([])
         expect(described_class.type).to eq(:online)
       end
     end
@@ -59,23 +65,16 @@
       end
 
       it "returns :online if the repository does not contain any base product" do
-        expect(Y2Packager::ProductLocation).to receive(:scan).and_return([])
+        expect(reader).to receive(:products).and_return([])
         expect(described_class.type).to eq(:online)
       end
 
       it "returns :standard if the repository contains any base product" do
-        details = Y2Packager::ProductLocationDetails.new(
-          product:         "SLES",
-          summary:         "SUSE Linux Enterprise Server 15 SP1",
-          description:     "SUSE Linux Enterprise offers a comprehensive...",
-          order:           200,
-          base:            true,
-          depends_on:      [],
-          product_package: "sles-release"
+        prod = Y2Packager::RepoProductSpec.new(
+          name: "sles", dir: "/SLES", base: true
         )
-        prod = Y2Packager::ProductLocation.new("/", "/", product: details)
 
-        expect(Y2Packager::ProductLocation).to receive(:scan).and_return([prod])
+        expect(reader).to receive(:products).and_return([prod])
         expect(described_class.type).to eq(:standard)
       end
     end