knife-pkg 0.0.3 → 0.1.0

data/.gitignore

@@ -16,5 +16,6 @@ test/tmp
 test/version_tmp
 tmp
 vendor
+.vagrant
 
-/tags
+/tags

data/README.md

@@ -11,45 +11,71 @@ This is a plugin for [Chef's](http://www.opscode.com/chef) [knife](http://docs.o
 
 List all updates:
 
+ - without `chef`
+
+```sh
+$ knife pkg show updates "127.0.0.1" -z -x vagrant -P 'vagrant' -m -p 2222
+===> 127.0.0.1
+	base-files (new: 7.1wheezy2 | installed: 7.1wheezy1)
+	curl (new: 7.26.0-1+wheezy4 | installed: 7.26.0-1+wheezy3)
+	dmsetup (new: 2:1.02.74-8 | installed: 2:1.02.74-7)
+	dpkg (new: 1.16.12 | installed: 1.16.10)
+  ...
+```
+
+  - with `chef` search
+
 ```sh
 $ knife pkg show updates "*:*"
 ===> kpp1.example.com
-	 libxml2 (2.7.8.dfsg-2+squeeze7)
-	 postgresql-client-9.2 (9.2.4-2.pgdg60+1)
-	 gpgv (1.4.10-4+squeeze2)
-	 gnupg (1.4.10-4+squeeze2)
+  accountsservice (new: 0.6.15-2ubuntu9.6.1 | installed: 0.6.15-2ubuntu9.6)
+  apparmor (new: 2.7.102-0ubuntu3.9 | installed: 2.7.102-0ubuntu3.7)
+  apt (new: 0.8.16~exp12ubuntu10.15 | installed: 0.8.16~exp12ubuntu10.10)
+  apt-transport-https (new: 0.8.16~exp12ubuntu10.15 | installed: 0.8.16~exp12ubuntu10.10)
+  apt-utils (new: 0.8.16~exp12ubuntu10.15 | installed: 0.8.16~exp12ubuntu10.10)
+  apt-xapian-index (new: 0.44ubuntu5.1 | installed: 0.44ubuntu5)
+  ...
 ===> kpp2.example.com
-	 libxml2 (2.7.8.dfsg-2+squeeze7)
-	 postgresql-client-9.2 (9.2.4-2.pgdg60+1)
-	 gpgv (1.4.10-4+squeeze2)
-	 gnupg (1.4.10-4+squeeze2)
-...
+  abrt-libs.x86_64 (new: 2.0.8-16.el6.centos.1 | installed: 2.0.8-15.el6.centos)
+  abrt-tui.x86_64 (new: 2.0.8-16.el6.centos.1 | installed: 2.0.8-15.el6.centos)
+  bash.x86_64 (new: 4.1.2-15.el6_4 | installed: 4.1.2-14.el6)
+  bind-libs.x86_64 (new: 32:9.8.2-0.17.rc1.el6_4.6 | installed: 32:9.8.2-0.17.rc1.el6)
+  bind-utils.x86_64 (new: 32:9.8.2-0.17.rc1.el6_4.6 | installed: 32:9.8.2-0.17.rc1.el6)
+  busybox.x86_64 (new: 1:1.15.1-16.el6_4 | installed: 1:1.15.1-15.el6)  
+  ...
 ```
 
-Install updates with user interaction:
+  - install updates with user interaction:
 
 ```sh
 $ knife pkg install updates "chef_environment:beta"
 ===> beta.example.com
-	The following updates are available:
-	libxml2 (2.7.8.dfsg-2+squeeze7)
-	libxml2-dev (2.7.8.dfsg-2+squeeze7)
-	Should I update all packages? [y|n]: n
-	Should I update libxml2 (2.7.8.dfsg-2+squeeze7)? [y|n]: y
-	libxml2 (2.7.8.dfsg-2+squeeze7) updated!
-	Should I update libxml2-dev (2.7.8.dfsg-2+squeeze7)? [y|n]: y
-	libxml2-dev (2.7.8.dfsg-2+squeeze7) updated!
+  The following updates are available:
+  NetworkManager.x86_64 (new: 1:0.9.8.2-9.git20130709.fc19 | installed: 1:0.9.8.2-2.fc19)
+	NetworkManager-glib.x86_64 (new: 1:0.9.8.2-9.git20130709.fc19 | installed: 1:0.9.8.2-2.fc19)
+  audit.x86_64 (new: 2.3.2-1.fc19 | installed: 2.3.1-2.fc19)
+  audit-libs.x86_64 (new: 2.3.2-1.fc19 | installed: 2.3.1-2.fc19)
+  ...
+  Do you want to update all packages? [y|n]: n
+  Do you want to update audit.x86_64 (2.3.2-1.fc19)? [y|n]: y
+  Do you want to update NetworkManager.x86_64 (1:0.9.8.2-9.git20130709.fc19)? [y|n]: y
+  Do you want to update ca-certificates.noarch (2013.1.94-1.fc19)? [y|n]: y
+  Do you want to update cronie.x86_64 (1.4.10-7.fc19)? [y|n]: n
+  ...
 ===> beta.bar.de
-	The following updates are available:
-	libxml2 (2.7.8.dfsg-2+squeeze7)
-	libxml2-dev (2.7.8.dfsg-2+squeeze7)
-	Should I update all packages? [y|n]: y
-	Updating...
-	all packages updated!
-...
+  The following updates are available:
+  ...
+  tzdata.noarch (new: 2013g-1.fc19 | installed: 2013c-1.fc19)
+  util-linux.x86_64 (new: 2.23.2-4.fc19 | installed: 2.23.1-3.fc19)
+  vim-minimal.x86_64 (new: 2:7.4.027-2.fc19 | installed: 2:7.3.944-1.fc19)
+  wget.x86_64 (new: 1.14-8.fc19 | installed: 1.14-5.fc19)
+  yum.noarch (new: 3.4.3-111.fc19 | installed: 3.4.3-99.fc19)
+  Do you want to update all packages? [y|n]: y
+  updating...
+  all packages updated!
 ```
 
-Install defined updates without confirmation, ask for all others:
+  - install defined updates without confirmation, ask for all others:
 
 ```sh
 $ knife pkg install updates "roles:webserver" -U "libxml2,gpgv,gnupg"
@@ -72,8 +98,7 @@ $ knife pkg install updates "roles:webserver" -U "libxml2,gpgv,gnupg"
 	Updating gnupg (1.4.10-4+squeeze2)
 ===> s6.example.com
 	Updating libxml2 (2.7.8.dfsg-2+squeeze7)
-===> staging.fuchstreff.de
-===> postgres-staging.sauspiel.de
+===> s6.example.com
 ===> s7.example.com
 	Updating libxml2 (2.7.8.dfsg-2+squeeze7)
 ===> s8.example.com
@@ -81,11 +106,20 @@ $ knife pkg install updates "roles:webserver" -U "libxml2,gpgv,gnupg"
 ...
 ```
 
+## Supported Packet Managers
+
+* apt
+* yum
+* *look at [example](https://github.com/hamann/knife-pkg/blob/master/lib/knife-pkg/controllers/yum.rb) and send PRs*
+
+Which packet manager will be used depends on what `ohai` (or `chef`) reports as [`platform_family`](https://github.com/opscode/ohai/blob/master/lib/ohai/plugins/linux/platform.rb#L103) for a node. So it should work if your node is of type 'debian' (=> apt), 'fedora' or 'rhel' (=> yum)
+
+
 ## Requirements
 
 * SSH access
 * Chef(-Server) or anything else which supports `search(:node, "*:*")` (*not required when you use `-m`*)
-* when `-m` option is given, `ohai` has to be installed on the node 
+* when `-m` option is given, `ohai` has to be installed on the node  ( sudo gem install ohai --no-ri --no-rdoc )
 
 
 ## Installation
@@ -103,12 +137,6 @@ Or install it yourself as:
     $ gem install knife-pkg
     
 
-## Supported Platforms
-
-* Debian/Ubuntu
-* *look at [example](https://github.com/hamann/knife-pkg/blob/master/lib/knife-pkg/controllers/debian.rb) and send PRs*
-  
-
 ## Overview
 
 The plugin inherits from `Knife::Ssh`, so almost all options and configuration settings are supported.

data/Vagrantfile

@@ -1,6 +1,8 @@
 boxes = {
   :debian => { :image => "https://opscode-vm-bento.s3.amazonaws.com/vagrant/opscode_debian-7.1.0_provisionerless.box" },
-  :ubuntu => { :image => "https://opscode-vm-bento.s3.amazonaws.com/vagrant/opscode_ubuntu-12.04_provisionerless.box" }
+  :ubuntu => { :image => "https://opscode-vm-bento.s3.amazonaws.com/vagrant/opscode_ubuntu-12.04_provisionerless.box" },
+  :centos => { :image => "https://opscode-vm-bento.s3.amazonaws.com/vagrant/opscode_centos-6.4_provisionerless.box" },
+  :fedora => { :image => "https://opscode-vm-bento.s3.amazonaws.com/vagrant/opscode-fedora-19_provisionerless.box" }
 }
 
 Vagrant::configure("2") do |config|

data/lib/chef/knife/pkg_base.rb

@@ -70,8 +70,8 @@ class Chef
     def node_by_hostname(hostname)
       node = nil
       if config[:manual]
-        obj = Struct.new(:fqdn)
-        node = obj.new(hostname)
+        node = Hash.new
+        node[:fqdn] = hostname
       else
         @action_nodes.each do |n|
           if hostname_by_attribute(n) == hostname

data/lib/knife-pkg/controllers/{debian.rb → apt.rb}

@@ -18,47 +18,62 @@ require 'knife-pkg'
 
 module Knife
   module Pkg
-    class DebianPackageController < PackageController
+    class AptPackageController < PackageController
 
       def initialize(node, session, opts = {})
         super(node, session, opts)
       end
 
+      def dry_run_supported?
+        true
+      end
+
       def update_pkg_cache
-        ShellCommand.exec("#{sudo}apt-get update", @session)
+        exec("#{sudo}apt-get update")
       end
 
       def last_pkg_cache_update
         raise_update_notifier_missing! unless update_notifier_installed?
 
-        result = ShellCommand.exec("stat -c %y /var/lib/apt/periodic/update-success-stamp", @session)
-        Time.parse(result.stdout.chomp)
+        result = nil
+        begin
+          result = exec("stat -c %y /var/lib/apt/periodic/update-success-stamp")
+          Time.parse(result.stdout.chomp)
+        rescue RuntimeError => e
+          e.backtrace.each { |l| Chef::Log.debug(l) }
+          Chef::Log.warn(e.message)
+          Time.now - (max_pkg_cache_age + 100)
+        end
       end
 
       def installed_version(package)
-        ShellCommand.exec("dpkg -p #{package.name} | grep -i Version: | awk '{print $2}'", @session).stdout.chomp
+        exec("dpkg -p #{package.name} | grep -i Version: | awk '{print $2}' | head -1").stdout.chomp
+      end
+
+      def update_version(package)
+        exec("#{sudo} apt-cache policy #{package.name} | grep Candidate | awk '{print $2}'").stdout.chomp
       end
 
       def available_updates
         packages = Array.new
         raise_update_notifier_missing! unless update_notifier_installed?
-        result = ShellCommand.exec("#{sudo}/usr/lib/update-notifier/apt_check.py -p", @session)
+        result = exec("#{sudo}/usr/lib/update-notifier/apt_check.py -p")
         result.stderr.split("\n").each do |item|
           package = Package.new(item)
-          package.version = installed_version(package)
+          package.version = update_version(package)
           packages << package
         end
-        packages
+        packages.sort { |n,m| n.name <=> m.name }
       end
 
       def update_package!(package)
         cmd_string = "#{sudo} DEBIAN_FRONTEND=noninteractive apt-get install #{package.name} -y -o Dpkg::Options::='--force-confold'"
         cmd_string += " -s" if @options[:dry_run]
-        ShellCommand.exec(cmd_string, @session)
+        exec(cmd_string)
       end
 
       def update_notifier_installed?
-        ShellCommand.exec("dpkg-query -W update-notifier-common 2>/dev/null || echo 'false'", @session).stdout.chomp != 'false'
+        exec("dpkg-query -W update-notifier-common 2>/dev/null || echo 'false'").stdout.chomp != 'false'
       end
 
       def raise_update_notifier_missing!

data/lib/knife-pkg/controllers/package_controller.rb

@@ -21,6 +21,8 @@ module Knife
   module Pkg
     class PackageController
 
+      ONE_DAY_IN_SECS = 86500
+
       attr_accessor :node
       attr_accessor :session
       attr_accessor :options
@@ -40,10 +42,23 @@ module Knife
         @options[:sudo] ? 'sudo ' : ''
       end
 
+      def exec(cmd)
+        ShellCommand.exec(cmd, @session)
+      end
+
+      def max_pkg_cache_age
+        options[:max_pkg_cache_age] || ONE_DAY_IN_SECS
+      end
+
       ## ++ methods to implement
       
       # update the package cache 
       # e.g apt-get update
+
+      def dry_run_supported?
+        false
+      end
+
       def update_pkg_cache
         raise NotImplementedError
       end
@@ -58,6 +73,11 @@ module Knife
         raise NotImplementedError
       end
 
+      # returns the version string of the available update for a package
+      def update_version(package)
+        raise NotImplementedError
+      end
+
       # returns an `Array` of all available updates
       def available_updates
         raise NotImplementedError
@@ -72,8 +92,18 @@ module Knife
 
       ## ++ methods to implement
       
+      def update_info(packages)
+        result = []
+        packages.each do |pkg|
+          installed_version = installed_version(pkg)
+          result << "#{pkg.name} (new: #{pkg.version} | installed: #{installed_version})"
+        end
+        result
+      end
 
       def update_package_verbose!(package)
+        raise NotImplementedError, "\"dry run\" isn't supported for this platform! (maybe a bug)" if @options[:dry_run] && !dry_run_supported?
+
         result = update_package!(package)
         if @options[:dry_run] || @options[:verbose]
           ui.info(result.stdout)
@@ -82,7 +112,7 @@ module Knife
       end
 
       def try_update_pkg_cache
-        if Time.now - last_pkg_cache_update > 86400 # 24 hours
+        if Time.now - last_pkg_cache_update > max_pkg_cache_age 
           @ui.info("Updating package cache...")
           update_pkg_cache
         end
@@ -92,9 +122,7 @@ module Knife
         return if packages.count == 0
 
         ui.info("\tThe following updates are available:") if packages.count > 0
-        packages.each do |package|
-          ui.info(ui.color("\t" + package.to_s, :yellow))
-        end
+        PackageController::list_available_updates(update_info(packages))
 
         if UserDecision.yes?("\tDo you want to update all packages? [y|n]: ")
           ui.info("\tupdating...")
@@ -118,6 +146,14 @@ module Knife
         end
       end
 
+      # Connects to the node, updates packages (defined with param `packages`) without confirmation, all other available updates with confirmation
+      # @param [Hash] node the node
+      # @option node [String] :platform_family platform of the node, e.g. `debian`. if not set, `ohai` will be executed
+      # @param [Session] session the ssh session to be used to connect to the node
+      # @param [Array<String>] packages name of the packages which should be updated without confirmation
+      # @param [Hash] opts the options
+      # @option opts [Boolean] :dry_run wether the update should only be simulated (if supported by the package manager)
+      # @option opts [Boolean] :verbose wether the update process should be more verbose
       def self.update!(node, session, packages, opts)
         ctrl = self.init_controller(node, session, opts)
 
@@ -127,6 +163,9 @@ module Knife
         ctrl.try_update_pkg_cache
         available_updates = ctrl.available_updates
 
+        # install packages in auto_updates without confirmation, 
+        # but only if they are available as update 
+        # don't install packages which aren't installed 
         available_updates.each do |avail|
           if auto_updates.select { |p| p.name == avail.name }.count == 0
             updates_for_dialog << avail
@@ -143,38 +182,23 @@ module Knife
         ctrl = self.init_controller(node, session, opts)
         ctrl.try_update_pkg_cache
         updates = ctrl.available_updates
-        list_available_updates(updates)
+        list_available_updates(ctrl.update_info(updates))
       end
 
       def self.init_controller(node, session, opts)
-        begin
-          ctrl_name = ''
-          if node.has_key?(:platform)
-            ctrl_name = self.controller_name(node.platform)
-          else
-            platform = self.platform_by_local_ohai(session, opts)
-            ctrl_name = self.controller_name(platform)
-          end
-          require File.join(File.dirname(__FILE__), ctrl_name)
-        rescue LoadError
-          raise NotImplementedError, "I'm sorry, but #{node.platform} is not supported!"
-        end
+        platform_family = node[:platform_family] || self.platform_family_by_local_ohai(session, opts)
+        ctrl_name = PlatformFamily.map_to_pkg_ctrl(platform_family)
+        raise NotImplementedError, "I'm sorry, but #{node[:platform_family]} is not supported!" if ctrl_name == 'unknown'
+
+        Chef::Log.debug("Platform Family #{platform_family} detected, using #{ctrl_name}")
+        require File.join(File.dirname(__FILE__), ctrl_name)
         ctrl = Object.const_get('Knife').const_get('Pkg').const_get("#{ctrl_name.capitalize}PackageController").new(node, session, opts)
         ctrl.ui = self.ui
         ctrl
       end
 
-      def self.platform_by_local_ohai(session, opts)
-        ShellCommand.exec("ohai platform| grep \\\"", session).stdout.strip.gsub(/\"/,'')
-      end
-
-      def self.controller_name(platform)
-        case platform
-        when 'debian', 'ubuntu'
-          'debian'
-        else
-          platform
-        end
+      def self.platform_family_by_local_ohai(session, opts)
+        ShellCommand.exec("ohai platform_family| grep \\\"", session).stdout.strip.gsub(/\"/,'')
       end
     end
   end

data/lib/knife-pkg/controllers/yum.rb

@@ -0,0 +1,65 @@
+#
+# Copyright 2013, Holger Amann <holger@fehu.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require 'knife-pkg'
+
+module Knife
+  module Pkg
+    class YumPackageController < PackageController
+
+      def initialize(node, session, opts = {})
+        super(node, session, opts)
+      end
+
+      def dry_run_supported?
+        false
+      end
+
+      def update_pkg_cache
+        # not necessary
+      end
+
+      def last_pkg_cache_update
+        return Time.now 
+      end
+
+      def installed_version(package)
+        exec("#{sudo}yum list installed | egrep \"^#{package.name}\" | awk '{print $2}'").stdout.chomp
+      end
+
+      def update_version(package)
+        exec("#{sudo}yum check-update -q | egrep \"^#{package.name}\" | awk '{print $2}'").stdout.chomp
+      end
+
+      def available_updates
+        packages = Array.new
+        result = exec("#{sudo}yum check-update -q| awk '{ print $1, $2 }'")
+        result.stdout.split("\n").each do |item|
+          next unless item.match(/^\s+$/).nil?
+          name, version = item.split(" ")
+          package = Package.new(name, version)
+          packages << package
+        end
+        packages
+      end
+
+      def update_package!(package)
+        cmd_string = "#{sudo}yum -d0 -e0 -y install #{package.name}"
+        exec(cmd_string)
+      end
+    end
+  end
+end

data/lib/knife-pkg/platform_family.rb

@@ -0,0 +1,18 @@
+module Knife
+  module Pkg
+    class PlatformFamily
+      class << self
+        def map_to_pkg_ctrl(name)
+          case name
+          when 'debian'
+            'apt'
+          when 'rhel', 'fedora'
+            'yum'
+          else
+            'unknown'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/knife-pkg/version.rb

@@ -1,5 +1,5 @@
 module Knife
   module Pkg
-    VERSION = '0.0.3'
+    VERSION = '0.1.0'
   end
 end

data/lib/knife-pkg.rb

@@ -19,6 +19,7 @@ require 'knife-pkg/package'
 require 'knife-pkg/shell_command'
 require 'knife-pkg/shell_command_result'
 require 'knife-pkg/user_decision'
+require 'knife-pkg/platform_family'
 require 'knife-pkg/controllers/package_controller'
 
 module Knife

data/spec/controllers/apt_spec.rb

@@ -0,0 +1,59 @@
+require 'knife-pkg'
+require 'knife-pkg/controllers/apt'
+
+include Knife::Pkg
+
+describe 'AptPackageController' do
+  describe '#new' do
+    it 'should create an instance of AptPkgCtrl' do
+      p = AptPackageController.new('a', 'b', :h => 1)
+      expect(p).to be_an_instance_of(AptPackageController)
+      expect(p.node).to eq('a')
+      expect(p.session).to eq('b')
+      expect(p.options).to eq(:h => 1)
+    end
+  end
+
+  describe '#dry_run_supported?' do
+    it 'should return true' do
+      p = AptPackageController.new(nil, nil, {})
+      expect(p.dry_run_supported?).to eq true
+    end
+  end
+
+  describe "#last_pkg_cache_update" do
+    it 'should return a time object' do
+      t = Time.now
+      result = ShellCommandResult.new(nil,"2013-10-07 09:58:34.000000000 +0200\n",nil,nil)
+
+      p = AptPackageController.new(nil, nil)
+      p.stub(:exec).and_return(result)
+      expect(p.last_pkg_cache_update).to be_an_instance_of Time
+      expect(p.last_pkg_cache_update).to eq(Time.parse("2013-10-07 09:58:34.000000000 +0200")) 
+    end
+  end
+
+  describe "#available_updates" do
+    it 'should raise an error if update-notifier is not installed' do
+      p = AptPackageController.new(nil, nil)
+      p.stub(:update_notifier_installed?).and_return(false)
+      expect{p.available_updates}.to raise_error(/update-notifier/)
+    end
+
+    it 'should return an array' do
+      result = ShellCommandResult.new(nil, nil, "b\na\nc", nil)
+      p = AptPackageController.new(nil, nil)
+      p.stub(:exec).and_return(result)
+      p.stub(:update_notifier_installed?).and_return(true)
+      p.stub(:installed_version).and_return("1.0.0")
+      p.stub(:update_version).and_return("2.0.0")
+
+      updates = p.available_updates
+      expect(updates).to be_an_instance_of Array
+      expect(updates.count).to eq(3)
+      expect(updates[0].name).to eq("a")
+      expect(updates[1].name).to eq("b")
+      expect(updates[2].name).to eq("c")
+    end
+  end
+end

data/spec/controllers/package_controller_spec.rb

@@ -3,6 +3,12 @@ require 'knife-pkg'
 include Knife::Pkg
 
 describe 'PackageController' do
+  before :each do
+    @ui = Object.new
+    @ui.stub(:info)
+    @ui.stub(:error)
+  end
+
   describe '#new' do
   end
 
@@ -18,11 +24,158 @@ describe 'PackageController' do
     end
   end
 
+  describe '#exec' do
+    it 'should call ShellCommand and return a ShellCommandResult' do
+      p = PackageController.new(nil, 'a')
+      cmd = "ls -l"
+      r = Struct.new(:stdout, :stderr)
+      result = r.new('a', 'b')
+      ShellCommand.stub(:exec).with(cmd, p.session).and_return(r)
+      expect(ShellCommand).to receive(:exec).with(cmd, p.session)
+      expect(p.exec(cmd)).to eq(r)
+    end
+  end
+
   describe '.init_controller' do
-    it 'should initialize the right package controller' do
-      FakeNode = Struct.new(:platform)
-      node = FakeNode.new("debian")
-      PackageController.init_controller(node, nil, nil)
+    it 'should initialize the right package controller if node[:platform_family] is not set' do
+      node = Hash.new
+      node[:platform_family] = 'debian'
+      expect(PackageController).to_not receive(:platform_family_by_local_ohai)
+      ctrl = PackageController.init_controller(node, nil, nil)
+      expect(ctrl).to be_an_instance_of AptPackageController
+     end
+
+    it 'should call ohai if node[:platform_family] is not set' do
+      PackageController.stub(:platform_family_by_local_ohai).and_return('debian')
+      expect(PackageController).to receive(:platform_family_by_local_ohai)
+      ctrl = PackageController.init_controller({}, nil, nil)
+      expect(ctrl).to be_an_instance_of AptPackageController
+    end
+
+    it 'should raise an error if platform family could not be mapped' do
+      node = { :platform_family => 'suse' }
+      expect{PackageController.init_controller(node, nil, {})}.to raise_error(NotImplementedError)
+    end
+
+  end
+
+  describe '#update_info' do
+    it 'should return an array of strings with package update information' do
+      ctrl = PackageController.new(nil, nil)
+      pkg = Package.new("a", "1.0.1")
+      pkg2 = Package.new("b", "2.0.2")
+
+      ctrl.stub(:installed_version).with(pkg).and_return("1.0.0")
+      ctrl.stub(:installed_version).with(pkg2).and_return("2.0.0")
+
+
+      strings = ctrl.update_info([pkg, pkg2])
+      expect(strings.count).to eq(2)
+      expect(strings[0]).to match(/a.+1\.0\.1.+1\.0\.0/)
+      expect(strings[1]).to match(/b.+2\.0\.2.+2\.0\.0/)
+    end
+  end
+
+  describe '#update_package_verbose!' do
+    it 'should raise an error if dry run is not supported' do
+      ctrl = PackageController.new(nil, nil, :dry_run => true)
+      expect{ctrl.update_package_verbose!([])}.to raise_error(NotImplementedError)
+    end
+
+    it 'should not print stdout and stderr dry_run or verbose are not set' do
+      ctrl = PackageController.new(nil, {})
+      ctrl.ui = @ui
+      r = Struct.new(:stdout, :stderr)
+      result = r.new("a", "b")
+
+      ctrl.stub(:update_package!).and_return(result)
+      expect(ctrl.ui).to_not receive(:info)
+      expect(ctrl.ui).to_not receive(:error)
+      ctrl.update_package_verbose!([0])
+    end
+
+    it 'should print stdout and stderr if dry_run is set' do
+      ctrl = PackageController.new(nil, {})
+      ctrl.ui = @ui
+      r = Struct.new(:stdout, :stderr)
+      result = r.new("a", "b")
+
+      ctrl.options[:dry_run] = true
+      ctrl.stub(:dry_run_supported?).and_return(true)
+      ctrl.stub(:update_package!).and_return(result)
+      expect(ctrl.ui).to receive(:info).with("a")
+      expect(ctrl.ui).to receive(:error).with("b")
+      ctrl.update_package_verbose!([0])
+    end
+
+    it 'should print stdout and stderr if verbose is set' do
+      ctrl = PackageController.new(nil, {})
+      ctrl.ui = @ui
+
+      r = Struct.new(:stdout, :stderr)
+      result = r.new("a", "b")
+
+      ctrl.options[:dry_run] = true
+      ctrl.stub(:dry_run_supported?).and_return(true)
+      ctrl.stub(:update_package!).and_return(result)
+      expect(ctrl.ui).to receive(:info).with("a")
+      expect(ctrl.ui).to receive(:error).with("b")
+      ctrl.update_package_verbose!([0])
+    end
+  end
+
+  describe "#try_update_pkg_cache" do
+    it 'should call update_pkg_cache' do
+      ctrl = PackageController.new(nil, nil)
+      ctrl.ui = @ui
+      ctrl.stub(:last_pkg_cache_update).and_return(Time.now - PackageController::ONE_DAY_IN_SECS)
+      expect(ctrl).to receive(:update_pkg_cache)
+      ctrl.try_update_pkg_cache
+    end
+  end
+
+  describe '.list_available_updates' do
+    it 'should list available updates' do
+      p = Package.new('1'); p2 = Package.new('p2')
+      Chef::Knife::UI.any_instance.stub(:info)
+      PackageController.list_available_updates([p,p2])
+    end
+  end
+
+  describe '.platform_family_by_local_ohai' do
+    it 'should call ohai to determine the platform family' do
+      r = Struct.new(:stdout)
+      result = r.new("  \"mac_os_x\"")
+      ShellCommand.stub(:exec).and_return(result)
+      expect(ShellCommand).to receive(:exec)
+      expect(PackageController.platform_family_by_local_ohai(nil, nil)).to eq("mac_os_x")
+    end
+  end
+
+  describe '.update!' do
+    it 'should install available updates' do
+      node = { :platform_family => 'debian' }
+      packages = ["a","b","c"]
+      package_for_dialog = Package.new("d")
+      available_updates = [ Package.new("a"), Package.new("b"), package_for_dialog ]
+
+      ctrl = PackageController.new(node, nil, {})
+      ctrl.ui = @ui
+      Chef::Knife::UI.any_instance.stub(:info)
+
+      PackageController.stub(:init_controller).with(node, nil, {}).and_return(ctrl)
+      ctrl.stub(:try_update_pkg_cache)
+      ctrl.stub(:available_updates).and_return(available_updates)
+      ctrl.stub(:update_package_verbose!).with([Package.new("a"), Package.new("b")])
+      ctrl.stub(:dry_run_supported?).and_return(true)
+      ctrl.stub(:update_dialog).with([package_for_dialog])
+
+      expect(PackageController).to receive(:init_controller).with(node, nil, {})
+      expect(ctrl).to receive(:try_update_pkg_cache)
+      expect(ctrl).to receive(:available_updates)
+      expect(ctrl).to receive(:update_package_verbose!).exactly(2).times
+      expect(ctrl).to receive(:update_dialog).with([package_for_dialog])
+      PackageController.update!(node, nil, packages, {})
     end
   end
 end

data/spec/controllers/yum_spec.rb

@@ -0,0 +1,84 @@
+require 'knife-pkg'
+require 'knife-pkg/controllers/yum'
+
+include Knife::Pkg
+
+describe 'YumPackageController' do
+  describe '#new' do
+    it 'should create an instance of YumPkgCtrl' do
+      p = YumPackageController.new('a', 'b', :h => 1)
+      expect(p).to be_an_instance_of(YumPackageController)
+      expect(p.node).to eq('a')
+      expect(p.session).to eq('b')
+      expect(p.options).to eq(:h => 1)
+    end
+  end
+
+  describe "#dry_run_supported?" do
+    it 'should return false' do
+      p = YumPackageController.new(nil, nil, {})
+      expect(p.dry_run_supported?).to eq false
+    end
+  end
+
+  describe "#last_pkg_cache_update" do
+    it 'should return a time object' do
+      p = YumPackageController.new(nil, nil)
+      expect(p.last_pkg_cache_update).to be_an_instance_of Time
+      expect(p.last_pkg_cache_update.to_s).to eq(Time.now.to_s)
+    end
+  end
+
+  describe "#installed_version" do
+    it 'should return the installed version of a package as string' do
+      r = Struct.new(:stdout)
+      result = r.new("3.2.29-40.el6.centos\n")
+
+      p = YumPackageController.new(nil, nil)
+      p.stub(:exec).and_return(result)
+      expect(p).to receive(:sudo)
+      expect(p.installed_version(Package.new("a"))).to eq("3.2.29-40.el6.centos")
+    end
+  end
+
+  describe "#update_version" do
+    it 'should return the installed version of a package as string' do
+      r = Struct.new(:stdout)
+      result = r.new("3.2.29-40.el6.centos\n")
+
+      p = YumPackageController.new(nil, nil)
+      p.stub(:exec).and_return(result)
+      expect(p).to receive(:sudo)
+      expect(p.update_version(Package.new("a"))).to eq("3.2.29-40.el6.centos")
+    end
+  end
+
+  describe "#available_updates" do
+    it 'should return an array of packages' do
+      r = Struct.new(:stdout)
+      result = r.new("   \nabrt.x86_64 2.0.8-16.el6.centos.1\nabrt-addon-ccpp.x86_64 2.0.8-16.el6.centos.1\n")
+
+      p = YumPackageController.new(nil, nil)
+      p.stub(:exec).and_return(result)
+
+      expect(p).to receive(:sudo)
+
+      updates = p.available_updates
+      expect(updates.count).to eq(2)
+      expect(updates[0].name).to eq("abrt.x86_64")
+      expect(updates[0].version).to eq("2.0.8-16.el6.centos.1")
+      expect(updates[1].name).to eq("abrt-addon-ccpp.x86_64")
+      expect(updates[1].version).to eq("2.0.8-16.el6.centos.1")
+    end
+  end
+
+  describe "#update_package!" do
+    it 'should update a package and return a ShellCommandResult' do
+      p = YumPackageController.new(nil, nil)
+      r = ShellCommandResult.new(nil,nil, "1\n2\n3", nil)
+      p.stub(:exec).and_return(r)
+      expect(p.update_package!(Package.new("a"))).to eq(r)
+    end
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-pkg
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-15 00:00:00.000000000 Z
+date: 2013-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -94,15 +94,18 @@ files:
 - lib/chef/knife/pkg_install_updates.rb
 - lib/chef/knife/pkg_show_updates.rb
 - lib/knife-pkg.rb
-- lib/knife-pkg/controllers/debian.rb
+- lib/knife-pkg/controllers/apt.rb
 - lib/knife-pkg/controllers/package_controller.rb
+- lib/knife-pkg/controllers/yum.rb
 - lib/knife-pkg/package.rb
+- lib/knife-pkg/platform_family.rb
 - lib/knife-pkg/shell_command.rb
 - lib/knife-pkg/shell_command_result.rb
 - lib/knife-pkg/user_decision.rb
 - lib/knife-pkg/version.rb
-- spec/controllers/debian_spec.rb
+- spec/controllers/apt_spec.rb
 - spec/controllers/package_controller_spec.rb
+- spec/controllers/yum_spec.rb
 - spec/package_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/hamann/knife-pkg
@@ -120,7 +123,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1027772782090820224
+      hash: 2359845024250157350
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -129,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1027772782090820224
+      hash: 2359845024250157350
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -137,7 +140,8 @@ signing_key:
 specification_version: 3
 summary: A plugin for chef's knife to manage package updates
 test_files:
-- spec/controllers/debian_spec.rb
+- spec/controllers/apt_spec.rb
 - spec/controllers/package_controller_spec.rb
+- spec/controllers/yum_spec.rb
 - spec/package_spec.rb
 - spec/spec_helper.rb

data/spec/controllers/debian_spec.rb

@@ -1,45 +0,0 @@
-require 'knife-pkg'
-require 'knife-pkg/controllers/debian'
-
-include Knife::Pkg
-
-describe 'DebianPackageController' do
-  describe '#new' do
-    it 'should create an instance of DebianPkgCtrl' do
-      p = DebianPackageController.new('a', 'b', :h => 1)
-      expect(p).to be_an_instance_of(DebianPackageController)
-      expect(p.node).to eq('a')
-      expect(p.session).to eq('b')
-      expect(p.options).to eq(:h => 1)
-    end
-  end
-
-  describe "#last_pkg_cache_update" do
-    it 'should return a time object' do
-      t = Time.now
-      result = ShellCommandResult.new(nil,"2013-10-07 09:58:34.000000000 +0200\n",nil,nil)
-      ShellCommand.stub(:exec).and_return(result)
-
-      p = DebianPackageController.new(nil, nil)
-      expect(p.last_pkg_cache_update).to be_an_instance_of Time
-      expect(p.last_pkg_cache_update).to eq(Time.parse("2013-10-07 09:58:34.000000000 +0200")) 
-    end
-  end
-
-  describe "#available_updates" do
-    it 'should raise an error if update-notifier is not installed' do
-      p = DebianPackageController.new(nil, nil)
-      p.stub(:update_notifier_installed?).and_return(false)
-      expect{p.available_updates}.to raise_error(/update-notifier/)
-    end
-
-    it 'should return an array' do
-      result = ShellCommandResult.new(nil, nil, "1\n2\n3", nil)
-      ShellCommand.stub(:exec).and_return(result)
-      p = DebianPackageController.new(nil, nil)
-      p.stub(:update_notifier_installed?).and_return(true)
-      p.stub(:installed_version).and_return("1.0.0")
-      expect(p.available_updates).to be_an_instance_of Array
-    end
-  end
-end