knife-ec-backup 3.0.5 → 3.0.9

data/spec/chef/knife/ec_key_base_spec.rb

@@ -1,6 +1,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
 require 'chef/knife/ec_key_base'
 require 'chef/automate'
+require 'sequel'
 
 class KeyBaseTester < Chef::Knife
   include Chef::Knife::EcKeyBase
@@ -38,4 +39,54 @@ describe Chef::Knife::EcKeyBase do
       expect(knife.config[:sql_password]).to eq("secrete")
     end
   end
+
+  # Regression coverage for the external-PostgreSQL bug: the SQL host/port must
+  # be sourced from chef-server-running.json (like sql_user/sql_password/sql_db),
+  # while an explicit --sql-host / --sql-port supplied on the CLI must still win.
+  describe "#load_config_from_file! PostgreSQL host/port autoconfiguration" do
+    let(:external_pg_running_config) {
+      '{"private_chef": { "opscode-erchef": {}, "postgresql": { "vip": "db.external.example.com", "port": 6432, "sql_user": "jiminy", "sql_password": "secret" } } }'
+    }
+
+    before(:each) do
+      allow(Chef::Automate).to receive(:is_installed?).and_return(false)
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with("/etc/opscode/chef-server-running.json").and_return(true)
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).with("/etc/opscode/chef-server-running.json").and_return(external_pg_running_config)
+    end
+
+    it "adopts the PostgreSQL host and port from chef-server-running.json when no CLI flag is given" do
+      knife.load_config_from_file!
+      expect(knife.config[:sql_host]).to eq("db.external.example.com")
+      expect(knife.config[:sql_port]).to eq(6432)
+    end
+
+    it "lets an explicit --sql-host / --sql-port win over the autoconfigured value" do
+      knife.config[:sql_host] = "cli-host.example.com"
+      knife.config[:sql_port] = 2345
+      knife.load_config_from_file!
+      expect(knife.config[:sql_host]).to eq("cli-host.example.com")
+      expect(knife.config[:sql_port]).to eq(2345)
+    end
+  end
+
+  # Regression coverage for #181: the configured database name must be written
+  # into the PostgreSQL connection URI. It was previously resolved but never
+  # applied, so PostgreSQL silently fell back to a database named after the user.
+  describe "#db connection URI" do
+    before(:each) do
+      # Capture the connection string instead of opening a real connection.
+      allow(Sequel).to receive(:connect) { |uri, *| uri }
+    end
+
+    it "includes the configured database name in the connection URI" do
+      knife.config[:sql_db] = "custom_db"
+      expect(knife.db).to include("/custom_db")
+    end
+
+    it "falls back to localhost:5432 when host and port are unset" do
+      expect(knife.db).to start_with("postgres://localhost:5432")
+    end
+  end
 end

data/spec/chef/knife/ec_restore_spec.rb

@@ -184,4 +184,194 @@ describe Chef::Knife::EcRestore do
       end
     end
   end
+
+  describe "#restore_cookbook_frozen_status" do
+    include FakeFS::SpecHelpers
+
+    let(:org_name) { "test_org" }
+    let(:chef_fs_config) { double("Chef::ChefFS::Config") }
+    let(:cookbooks_path) { "/organizations/#{org_name}/cookbooks" }
+
+    before(:each) do
+      allow(@knife).to receive(:dest_dir).and_return("")
+      allow(@knife).to receive(:ui).and_return(double("ui", :msg => nil, :warn => nil))
+    end
+
+    context "when cookbooks directory does not exist" do
+      it "returns early without processing" do
+        expect(@knife).not_to receive(:freeze_cookbook)
+        @knife.restore_cookbook_frozen_status(org_name, chef_fs_config)
+      end
+    end
+
+    context "when cookbooks directory exists" do
+      before(:each) do
+        FileUtils.mkdir_p(cookbooks_path)
+      end
+
+      context "with no cookbook directories" do
+        it "does not process any cookbooks" do
+          expect(@knife).not_to receive(:freeze_cookbook)
+          @knife.restore_cookbook_frozen_status(org_name, chef_fs_config)
+        end
+      end
+
+      context "with cookbook directories" do
+        let(:cookbook_name) { "apache2" }
+        let(:version) { "1.2.3" }
+        let(:cookbook_dir) { "#{cookbook_name}-#{version}" }
+        let(:cookbook_path) { File.join(cookbooks_path, cookbook_dir) }
+        let(:status_file) { File.join(cookbook_path, "status.json") }
+
+        before(:each) do
+          FileUtils.mkdir_p(cookbook_path)
+        end
+
+        context "when status.json does not exist" do
+          it "skips the cookbook" do
+            expect(@knife).not_to receive(:freeze_cookbook)
+            @knife.restore_cookbook_frozen_status(org_name, chef_fs_config)
+          end
+        end
+
+        context "when status.json exists" do
+          context "and cookbook is frozen" do
+            before(:each) do
+              File.write(status_file, '{"frozen": true}')
+            end
+
+            it "calls freeze_cookbook with correct parameters" do
+              expect(@knife).to receive(:freeze_cookbook).with(cookbook_name, version, org_name)
+              @knife.restore_cookbook_frozen_status(org_name, chef_fs_config)
+            end
+          end
+
+          context "and cookbook is not frozen" do
+            before(:each) do
+              File.write(status_file, '{"frozen": false}')
+            end
+
+            it "does not call freeze_cookbook" do
+              expect(@knife).not_to receive(:freeze_cookbook)
+              @knife.restore_cookbook_frozen_status(org_name, chef_fs_config)
+            end
+          end
+
+          context "and status.json has invalid JSON" do
+            before(:each) do
+              File.write(status_file, 'invalid json')
+            end
+
+            it "warns about parse error and continues" do
+              ui = double("ui")
+              allow(@knife).to receive(:ui).and_return(ui)
+              expect(ui).to receive(:msg).with("Restoring cookbook frozen status")
+              expect(ui).to receive(:warn).with(/Failed to parse status\.json/)
+              expect(@knife).not_to receive(:freeze_cookbook)
+              @knife.restore_cookbook_frozen_status(org_name, chef_fs_config)
+            end
+          end
+
+          context "with multiple cookbooks" do
+            let(:frozen_cookbook) { "frozen-cookbook-2.0.0" }
+            let(:unfrozen_cookbook) { "unfrozen-cookbook-1.5.0" }
+
+            before(:each) do
+              # Create frozen cookbook
+              FileUtils.mkdir_p(File.join(cookbooks_path, frozen_cookbook))
+              File.write(File.join(cookbooks_path, frozen_cookbook, "status.json"), '{"frozen": true}')
+
+              # Create unfrozen cookbook
+              FileUtils.mkdir_p(File.join(cookbooks_path, unfrozen_cookbook))
+              File.write(File.join(cookbooks_path, unfrozen_cookbook, "status.json"), '{"frozen": false}')
+            end
+
+            it "only freezes the frozen cookbook" do
+              expect(@knife).to receive(:freeze_cookbook).with("frozen-cookbook", "2.0.0", org_name).once
+              expect(@knife).not_to receive(:freeze_cookbook).with("unfrozen-cookbook", "1.5.0", org_name)
+              @knife.restore_cookbook_frozen_status(org_name, chef_fs_config)
+            end
+          end
+
+          context "with cookbook name containing hyphens" do
+            let(:cookbook_name) { "multi-word-cookbook" }
+            let(:version) { "1.0.0" }
+
+            before(:each) do
+              cookbook_dir = "#{cookbook_name}-#{version}"
+              cookbook_path = File.join(cookbooks_path, cookbook_dir)
+              FileUtils.mkdir_p(cookbook_path)
+              File.write(File.join(cookbook_path, "status.json"), '{"frozen": true}')
+            end
+
+            it "correctly parses cookbook name with hyphens" do
+              expect(@knife).to receive(:freeze_cookbook).with(cookbook_name, version, org_name)
+              @knife.restore_cookbook_frozen_status(org_name, chef_fs_config)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#freeze_cookbook" do
+    let(:cookbook_name) { "apache2" }
+    let(:version) { "1.2.3" }
+    let(:org_name) { "test_org" }
+    let(:manifest) { { "name" => cookbook_name, "version" => version, "frozen?" => false } }
+
+    before(:each) do
+      allow(@knife).to receive(:ui).and_return(double("ui", :msg => nil, :warn => nil))
+    end
+
+    context "when cookbook is not already frozen" do
+      before(:each) do
+        allow(@rest).to receive(:get).with("organizations/#{org_name}/cookbooks/#{cookbook_name}/#{version}").and_return(manifest)
+      end
+
+      it "freezes the cookbook successfully" do
+        frozen_manifest = manifest.dup.tap { |h| h["frozen?"] = true }
+        expect(@rest).to receive(:put).with("organizations/#{org_name}/cookbooks/#{cookbook_name}/#{version}?freeze=true", frozen_manifest)
+        @knife.freeze_cookbook(cookbook_name, version, org_name)
+      end
+    end
+
+    context "when cookbook is already frozen" do
+      let(:frozen_manifest) { { "name" => cookbook_name, "version" => version, "frozen?" => true } }
+
+      before(:each) do
+        allow(@rest).to receive(:get).with("organizations/#{org_name}/cookbooks/#{cookbook_name}/#{version}").and_return(frozen_manifest)
+      end
+
+      it "skips freezing and warns" do
+        ui = double("ui")
+        allow(@knife).to receive(:ui).and_return(ui)
+        expect(ui).to receive(:msg).with("Freezing cookbook #{cookbook_name} version #{version}")
+        expect(ui).to receive(:warn).with(/already frozen/)
+        expect(@rest).not_to receive(:put)
+        @knife.freeze_cookbook(cookbook_name, version, org_name)
+      end
+    end
+
+    context "when API call fails" do
+      before(:each) do
+        allow(@rest).to receive(:get).with("organizations/#{org_name}/cookbooks/#{cookbook_name}/#{version}").and_return(manifest)
+        allow(@rest).to receive(:put).and_raise(net_exception(500))
+        allow(@knife).to receive(:knife_ec_error_handler).and_return(double("error_handler", :add => nil))
+      end
+
+      it "handles the exception and adds to error handler" do
+        ui = double("ui")
+        error_handler = double("error_handler")
+        allow(@knife).to receive(:ui).and_return(ui)
+        allow(@knife).to receive(:knife_ec_error_handler).and_return(error_handler)
+
+        expect(ui).to receive(:msg).with("Freezing cookbook #{cookbook_name} version #{version}")
+        expect(ui).to receive(:warn).with(/Failed to freeze cookbook/)
+        expect(error_handler).to receive(:add)
+
+        @knife.freeze_cookbook(cookbook_name, version, org_name)
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knife-ec-backup
 version: !ruby/object:Gem::Version
-  version: 3.0.5
+  version: 3.0.9
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-19 00:00:00.000000000 Z
+date: 2026-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -95,6 +95,7 @@ files:
 - lib/chef/knife/ec_backup.rb
 - lib/chef/knife/ec_base.rb
 - lib/chef/knife/ec_error_handler.rb
+- lib/chef/knife/ec_import.rb
 - lib/chef/knife/ec_key_base.rb
 - lib/chef/knife/ec_key_export.rb
 - lib/chef/knife/ec_key_import.rb
@@ -106,6 +107,7 @@ files:
 - spec/chef/knife/ec_backup_spec.rb
 - spec/chef/knife/ec_base_spec.rb
 - spec/chef/knife/ec_error_handler_spec.rb
+- spec/chef/knife/ec_import_spec.rb
 - spec/chef/knife/ec_key_base_spec.rb
 - spec/chef/knife/ec_key_export_spec.rb
 - spec/chef/knife/ec_key_import_spec.rb