knife-inspect 0.8.0 → 0.9.0

data/spec/chef/knife/environment_inspect_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'chef/knife/environment_inspect'
+
+RSpec.describe Chef::Knife::EnvironmentInspect do
+  it_behaves_like 'a knife inspect runner' do
+    let :checklist do
+      HealthInspector::Checklists::Environments
+    end
+  end
+end

data/spec/chef/knife/inspect_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'chef/knife/inspect'
+
+RSpec.describe Chef::Knife::Inspect do
+  let :knife_inspect do
+    described_class.new
+  end
+
+  it 'inherits from Chef::Knife' do
+    expect(knife_inspect).to be_a Chef::Knife
+  end
+
+  describe '#run' do
+    subject do
+      knife_inspect.run
+    end
+
+    context 'when all the checklists pass' do
+      it 'runs all the check lists and exits with 0' do
+        { HealthInspector::Checklists::Cookbooks => true,
+          HealthInspector::Checklists::DataBags => true,
+          HealthInspector::Checklists::DataBagItems => true,
+          HealthInspector::Checklists::Environments => true,
+          HealthInspector::Checklists::Roles => true }.each do |checklist, status|
+          expect(checklist).to receive(:run).and_return status
+        end
+
+        expect(knife_inspect).to receive(:exit).with true
+
+        subject
+      end
+    end
+
+    context 'when one or more checklists fail' do
+      it 'runs all the check lists and exits with 1' do
+        { HealthInspector::Checklists::Cookbooks => true,
+          HealthInspector::Checklists::DataBags => false,
+          HealthInspector::Checklists::DataBagItems => true,
+          HealthInspector::Checklists::Environments => true,
+          HealthInspector::Checklists::Roles => true }.each do |checklist, status|
+          expect(checklist).to receive(:run).and_return status
+        end
+
+        expect(knife_inspect).to receive(:exit).with false
+
+        subject
+      end
+    end
+  end
+
+end

data/spec/chef/knife/role_inspect_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'chef/knife/role_inspect'
+
+RSpec.describe Chef::Knife::RoleInspect do
+  it_behaves_like 'a knife inspect runner' do
+    let :checklist do
+      HealthInspector::Checklists::Roles
+    end
+  end
+end

data/spec/health_inspector/checklists/cookbook_spec.rb

@@ -1,41 +1,43 @@
 require 'spec_helper'
 
-describe HealthInspector::Checklists::Cookbook do
-  let(:pairing) { described_class.new(health_inspector_context, :name => "dummy") }
+RSpec.describe HealthInspector::Checklists::Cookbook do
+  let(:pairing) do
+    described_class.new(health_inspector_context, :name => 'dummy')
+  end
 
-  it "should detect if an item does not exist locally" do
-    pairing.server = "0.0.1"
+  it 'detects if an item does not exist locally' do
+    pairing.server = '0.0.1'
     pairing.local  = nil
     pairing.validate
 
-    pairing.errors.should_not be_empty
-    pairing.errors.first.should == "exists on server but not locally"
+    expect(pairing.errors).not_to be_empty
+    expect(pairing.errors.first).to eq('exists on server but not locally')
   end
 
-  it "should detect if an item does not exist on server" do
+  it 'detects if an item does not exist on server' do
     pairing.server = nil
-    pairing.local  = "0.0.1"
+    pairing.local  = '0.0.1'
     pairing.validate
 
-    pairing.errors.should_not be_empty
-    pairing.errors.first.should == "exists locally but not on server"
+    expect(pairing.errors).not_to be_empty
+    expect(pairing.errors.first).to eq('exists locally but not on server')
   end
 
-  it "should detect if an item is different" do
-    pairing.server = "0.0.1"
-    pairing.local  = "0.0.2"
+  it 'detects if an item is different' do
+    pairing.server = '0.0.1'
+    pairing.local  = '0.0.2'
     pairing.validate
 
-    pairing.errors.should_not be_empty
-    pairing.errors.first.should == "chef server has 0.0.1 but local version is 0.0.2"
+    expect(pairing.errors).not_to be_empty
+    expect(pairing.errors.first).to eq('chef server has 0.0.1 but local version is 0.0.2')
   end
 
-  it "should detect if an item is the same" do
-    pairing.should_receive(:validate_changes_on_the_server_not_in_the_repo)
-    pairing.server = "0.0.1"
-    pairing.local  = "0.0.1"
+  it 'detects if an item is the same' do
+    expect(pairing).to receive(:validate_changes_on_the_server_not_in_the_repo)
+    pairing.server = '0.0.1'
+    pairing.local  = '0.0.1'
     pairing.validate
 
-    pairing.errors.should be_empty
+    expect(pairing.errors).to be_empty
   end
-end
+end

data/spec/health_inspector/checklists/cookbooks_spec.rb

@@ -1,35 +1,37 @@
 require 'spec_helper'
 
-describe HealthInspector::Checklists::Cookbooks do
+RSpec.describe HealthInspector::Checklists::Cookbooks do
   let :checklist do
     described_class.new(nil)
   end
 
   before do
-    expect(HealthInspector::Context).to receive(:new).with(nil).
-      and_return health_inspector_context
+    expect(HealthInspector::Context).to receive(:new).with(nil)
+      .and_return health_inspector_context
   end
 
   describe '#server_items' do
     it 'returns a list of roles from the chef server' do
-      health_inspector_context.stub_chain(:rest, :get_rest).
-        with('/cookbooks').and_return({
-        'cookbook_one' => { 'versions' => [{ 'version' => '1.0.0' }] },
-        'cookbook_two' => { 'versions' => [{ 'version' => '0.0.1' }] }
-      })
-      expect(checklist.server_items).to eq({
+      allow(health_inspector_context).to receive(:rest).and_return(double)
+      expect(health_inspector_context.rest).to receive(:get_rest)
+        .with('/cookbooks')
+        .and_return(
+          'cookbook_one' => { 'versions' => [{ 'version' => '1.0.0' }] },
+          'cookbook_two' => { 'versions' => [{ 'version' => '0.0.1' }] }
+      )
+      expect(checklist.server_items).to eq(
         'cookbook_one' => Chef::Version.new('1.0.0'),
         'cookbook_two' => Chef::Version.new('0.0.1')
-      })
+      )
     end
   end
 
   describe '#local_items' do
     it 'returns a list of roles from the chef repo' do
-      expect(checklist.local_items).to eq({
+      expect(checklist.local_items).to eq(
         'cookbook_one' => Chef::Version.new('1.0.0'),
         'cookbook_two' => Chef::Version.new('0.0.1')
-      })
+      )
     end
   end
 end

data/spec/health_inspector/checklists/data_bag_item_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe HealthInspector::Checklists::DataBagItem do
-  it_behaves_like "a chef model"
-  it_behaves_like "a chef model that can be represented in json"
+RSpec.describe HealthInspector::Checklists::DataBagItem do
+  it_behaves_like 'a chef model'
+  it_behaves_like 'a chef model that can be represented in json'
 end

data/spec/health_inspector/checklists/data_bag_items_spec.rb

@@ -1,31 +1,30 @@
 require 'spec_helper'
 
-describe HealthInspector::Checklists::DataBagItems do
+RSpec.describe HealthInspector::Checklists::DataBagItems do
   let :checklist do
     described_class.new(nil)
   end
 
   before do
-    expect(HealthInspector::Context).to receive(:new).with(nil).
-      and_return health_inspector_context
+    expect(HealthInspector::Context).to receive(:new).with(nil)
+      .and_return health_inspector_context
   end
 
   describe '#server_items' do
     it 'returns a list of data bag items from the chef server' do
-      expect(Chef::DataBag).to receive(:list).and_return({
+      expect(Chef::DataBag).to receive(:list).and_return(
         'data_bag_one'         => 'url',
         'data_bag_two'         => 'url',
         'data_bag_from_subdir' => 'url'
-      })
+      )
       { 'data_bag_one' => 'one',
         'data_bag_two' => 'two',
         'data_bag_from_subdir' => 'three' }.each do |data_bag, item|
-        expect(Chef::DataBag).to receive(:load).with(data_bag).
-          and_return({ item => 'url' })
+          expect(Chef::DataBag).to receive(:load).with(data_bag)
+            .and_return item => 'url'
         end
-      expect(checklist.server_items.sort).to eq [
-        'data_bag_from_subdir/three', 'data_bag_one/one', 'data_bag_two/two'
-      ]
+      expect(checklist.server_items.sort)
+        .to eq %w(data_bag_from_subdir/three data_bag_one/one data_bag_two/two)
     end
   end
 
@@ -36,4 +35,91 @@ describe HealthInspector::Checklists::DataBagItems do
       ]
     end
   end
+
+  describe '#load_item(name)' do
+    let :name do
+      'data_bag_one/one'
+    end
+
+    let :item do
+      checklist.load_item name
+    end
+
+    it 'instanciates a DataBagItem pairing for that item' do
+      expect(checklist).to receive(:load_item_from_local)
+        .with(name).and_return name
+      expect(checklist).to receive(:load_item_from_server)
+        .with(name).and_return name
+
+      expect(item).to be_a(HealthInspector::Checklists::DataBagItem)
+      expect(item.name).to eq(name)
+      expect(item.server).to eq(name)
+    end
+  end
+
+  describe '#load_item_from_local(name)' do
+    context 'when the data bag item exists' do
+      let :name do
+        'data_bag_one/one'
+      end
+
+      it 'returns a parsed version of the data bag item' do
+        expect(checklist.load_item_from_local(name))
+          .to eq('id' => 'one', 'some' => 'key')
+      end
+    end
+
+    context 'when the data bag item does not exist' do
+      let :name do
+        'data_bag_one/non_existent'
+      end
+
+      it 'returns nil' do
+        expect(checklist.load_item_from_local(name)).to be_nil
+      end
+    end
+
+    context 'when the data bag item is not valid json' do
+      let :name do
+        'data_bag_two/two'
+      end
+
+      it 'returns nil' do
+        expect(checklist.load_item_from_local(name)).to be_nil
+      end
+    end
+  end
+
+  describe '#load_item_from_server(name)' do
+    context 'when the data bag item exists' do
+      let :name do
+        'data_bag_one/one'
+      end
+
+      let :data_bag_item do
+        double(:raw_data => { 'id' => 'one', 'some' => 'key' })
+      end
+
+      it 'returns a parsed version of the data bag item' do
+        expect(Chef::DataBagItem).to receive(:load).with('data_bag_one', 'one')
+          .and_return(data_bag_item)
+        expect(checklist.load_item_from_server(name))
+          .to eq('id' => 'one', 'some' => 'key')
+      end
+    end
+
+    context 'when the data bag item does not exist' do
+      let :name do
+        'data_bag_one/non_existent'
+      end
+
+      it 'returns nil' do
+        expect(Chef::DataBagItem).to receive(:load)
+          .with('data_bag_one', 'non_existent')
+          .and_raise(Net::HTTPServerException.new('404 "Object Not Found"',
+                                                  'response'))
+        expect(checklist.load_item_from_server(name)).to be_nil
+      end
+    end
+  end
 end

data/spec/health_inspector/checklists/data_bag_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
 
-describe HealthInspector::Checklists::DataBag do
-  it_behaves_like "a chef model"
-end
+RSpec.describe HealthInspector::Checklists::DataBag do
+  it_behaves_like 'a chef model'
+end

data/spec/health_inspector/checklists/data_bags_spec.rb

@@ -1,33 +1,50 @@
 require 'spec_helper'
 
-describe HealthInspector::Checklists::DataBags do
+RSpec.describe HealthInspector::Checklists::DataBags do
   let :checklist do
     described_class.new(nil)
   end
 
   before do
-    expect(HealthInspector::Context).to receive(:new).with(nil).
-      and_return health_inspector_context
+    expect(HealthInspector::Context).to receive(:new).with(nil)
+      .and_return health_inspector_context
   end
 
   describe '#server_items' do
     it 'returns a list of data bags from the chef server' do
-      expect(Chef::DataBag).to receive(:list).and_return({
+      expect(Chef::DataBag).to receive(:list).and_return(
         'data_bag_one'         => 'url',
         'data_bag_two'         => 'url',
         'data_bag_from_subdir' => 'url'
-      })
-      expect(checklist.server_items.sort).to eq [
-        'data_bag_from_subdir', 'data_bag_one', 'data_bag_two'
-      ]
+      )
+      expect(checklist.server_items.sort)
+        .to eq %w(data_bag_from_subdir data_bag_one data_bag_two)
     end
   end
 
   describe '#local_items' do
     it 'returns a list of data bags from the chef repo' do
-      expect(checklist.local_items.sort).to eq [
-        'data_bag_from_subdir', 'data_bag_one', 'data_bag_two'
-      ]
+      expect(checklist.local_items.sort)
+        .to eq %w(data_bag_from_subdir data_bag_one data_bag_two)
+    end
+  end
+
+  describe '#load_item(name)' do
+    let :name do
+      'data bag'
+    end
+
+    let :item do
+      checklist.load_item name
+    end
+
+    it 'instanciates a DataBag pairing for that item' do
+      expect(checklist).to receive(:server_items).and_return ['data bag']
+      expect(checklist).to receive(:local_items).and_return ['data bag']
+      expect(item).to be_a(HealthInspector::Checklists::DataBag)
+      expect(item.name).to eq(name)
+      expect(item.server).to eq(true)
+      expect(item.local).to eq(true)
     end
   end
 end

data/spec/health_inspector/checklists/environment_spec.rb

@@ -1,18 +1,17 @@
 require 'spec_helper'
 
-describe HealthInspector::Checklists::Environment do
+RSpec.describe HealthInspector::Checklists::Environment do
   let(:pairing) { described_class.new(health_inspector_context) }
 
-  it_behaves_like "a chef model"
-  it_behaves_like "a chef model that can be represented in json"
+  it_behaves_like 'a chef model'
+  it_behaves_like 'a chef model that can be represented in json'
 
-  it "should ignore _default environment if it only exists on server" do
-    pairing.name   = "_default"
+  it 'ignores _default environment if it only exists on server' do
+    pairing.name   = '_default'
     pairing.server = {}
     pairing.local  = nil
     pairing.validate
 
-    pairing.errors.should be_empty
+    expect(pairing.errors).to be_empty
   end
-
 end

data/spec/health_inspector/checklists/environments_spec.rb

@@ -1,33 +1,31 @@
 require 'spec_helper'
 
-describe HealthInspector::Checklists::Environments do
+RSpec.describe HealthInspector::Checklists::Environments do
   let :checklist do
     described_class.new(nil)
   end
 
   before do
-    expect(HealthInspector::Context).to receive(:new).with(nil).
-      and_return health_inspector_context
+    expect(HealthInspector::Context).to receive(:new).with(nil)
+      .and_return health_inspector_context
   end
 
   describe '#server_items' do
     it 'returns a list of environments from the chef server' do
-      expect(Chef::Environment).to receive(:list).and_return({
+      expect(Chef::Environment).to receive(:list).and_return(
         'environment_one'         => 'url',
         'environment_two'         => 'url',
         'environment_from_subdir' => 'url'
-      })
-      expect(checklist.server_items.sort).to eq [
-        'environment_from_subdir', 'environment_one', 'environment_two'
-      ]
+      )
+      expect(checklist.server_items.sort)
+        .to eq %w(environment_from_subdir environment_one environment_two)
     end
   end
 
   describe '#local_items' do
     it 'returns a list of environments from the chef repo' do
-      expect(checklist.local_items.sort).to eq [
-        'environment_from_subdir', 'environment_one', 'environment_two'
-      ]
+      expect(checklist.local_items.sort)
+        .to eq %w(environment_from_subdir environment_one environment_two)
     end
   end
 end