diff --git a/lib/linux_admin.rb b/lib/linux_admin.rb
index 07fb097..26c471a 100644
--- a/lib/linux_admin.rb
+++ b/lib/linux_admin.rb
@@ -5,6 +5,7 @@
 
 require 'linux_admin/common'
 require 'linux_admin/exceptions'
+require 'linux_admin/command_result'
 require 'linux_admin/rpm'
 require 'linux_admin/version'
 require 'linux_admin/yum'
diff --git a/lib/linux_admin/command_result.rb b/lib/linux_admin/command_result.rb
new file mode 100644
index 0000000..9c57786
--- /dev/null
+++ b/lib/linux_admin/command_result.rb
@@ -0,0 +1,9 @@
+class CommandResult
+  attr_reader :output, :error, :exit_status
+
+  def initialize(output, error, exit_status)
+    @output      = output
+    @error       = error
+    @exit_status = exit_status
+  end
+end
diff --git a/lib/linux_admin/common.rb b/lib/linux_admin/common.rb
index 8282517..9876404 100644
--- a/lib/linux_admin/common.rb
+++ b/lib/linux_admin/common.rb
@@ -9,24 +9,35 @@ def cmd(cmd)
     def run(cmd, options = {})
       params = options[:params] || options[:parameters]
 
+      launch_params = {}
+      launch_params[:chdir] = options[:chdir] if options[:chdir]
+
+      output = ""
+      error  = ""
+      status = nil
+
       begin
-        launch_params = {}
-        launch_params[:chdir] = options[:chdir] if options[:chdir]
-        out = launch(build_cmd(cmd, params), launch_params)
-
-        if options[:return_output] && exitstatus == 0
-          out
-        elsif options[:return_exitstatus] || exitstatus == 0
-          exitstatus
-        else
-          raise CommandError, "#{build_cmd(cmd, params)}: exit code: #{exitstatus}"
-        end
-      rescue
-        return nil if options[:return_exitstatus]
-        raise
+        output, error = launch(build_cmd(cmd, params), launch_params)
+        status = exitstatus
       ensure
+        output ||= ""
+        error  ||= ""
         self.exitstatus = nil
       end
+
+      CommandResult.new(output, error, status)
+    end
+
+    def run!(cmd, options = {})
+      params = options[:params] || options[:parameters]
+      command_result = run(cmd, options)
+
+      if command_result.exit_status != 0
+        message = "#{cmd} exit code: #{command_result.exit_status}"
+        raise CommandResultError.new(message, command_result)
+      end
+
+      command_result
     end
 
     private
@@ -61,25 +72,28 @@ def build_cmd(cmd, params = nil)
     THREAD_SYNC_KEY = "LinuxAdmin-exitstatus"
 
     def launch(cmd, spawn_options = {})
-      pipe_r, pipe_w = IO.pipe
-      pid = Kernel.spawn(cmd, {:err => [:child, :out], :out => pipe_w}.merge(spawn_options))
-      wait_for_process(pid, pipe_w)
-      wait_for_output(pipe_r)
+      out_r, out_w = IO.pipe
+      err_r, err_w = IO.pipe
+      pid = Kernel.spawn(cmd, {:err => err_w, :out => out_w}.merge(spawn_options))
+      wait_for_process(pid, out_w, err_w)
+      wait_for_pipes(out_r, err_r)
     end
 
-    def wait_for_process(pid, pipe_w)
+    def wait_for_process(pid, out_w, err_w)
       self.exitstatus = :not_done
       Thread.new(Thread.current) do |parent_thread|
         _, status = Process.wait2(pid)
-        pipe_w.close
+        out_w.close
+        err_w.close
         parent_thread[THREAD_SYNC_KEY] = status.exitstatus
       end
     end
 
-    def wait_for_output(pipe_r)
-      out = pipe_r.read
+    def wait_for_pipes(out_r, err_r)
+      out = out_r.read
+      err = err_r.read
       sleep(0.1) while exitstatus == :not_done
-      return out
+      return out, err
     end
 
     def exitstatus
diff --git a/lib/linux_admin/disk.rb b/lib/linux_admin/disk.rb
index d70750b..e704930 100644
--- a/lib/linux_admin/disk.rb
+++ b/lib/linux_admin/disk.rb
@@ -22,9 +22,7 @@ def initialize(args = {})
     def size
       @size ||= begin
         size = nil
-        out = run(cmd(:fdisk),
-                  :return_output => true,
-                  :params => {"-l" => nil})
+        out = run!(cmd(:fdisk), :params => {"-l" => nil}).output
         out.each_line { |l|
           if l =~ /Disk #{path}: ([0-9\.]*) ([KMG])B.*/
             size = case $2
@@ -46,13 +44,11 @@ def partitions
       @partitions ||= begin
         partitions = []
 
+        # TODO: Should this really catch non-zero RC, set output to the default "" and silently return [] ?
+        #   If so, should other calls to parted also do the same?
         # requires sudo
         out = run(cmd(:parted),
-                  :return_exitstatus => true,
-                  :return_output => true,
-                  :params => { nil => [@path, 'print'] })
-
-        return [] if out.kind_of?(Fixnum)
+                  :params => { nil => [@path, 'print'] }).output
 
         out.each_line do |l|
           if l =~ /^ [0-9].*/
@@ -98,7 +94,7 @@ def create_partition(partition_type, size)
           [(partitions.last.id + 1),
             partitions.last.end_sector]
 
-      run(cmd(:parted),
+      run!(cmd(:parted),
           :params => { nil => [path, 'mkpart', partition_type,
                                start, start + size]})
 
@@ -116,7 +112,7 @@ def clear!
       @partitions = []
 
       # clear partition table
-      run(cmd(:dd),
+      run!(cmd(:dd),
           :params => { 'if=' => '/dev/zero', 'of=' => @path,
                        'bs=' => 512, 'count=' => 1})
 
diff --git a/lib/linux_admin/exceptions.rb b/lib/linux_admin/exceptions.rb
index 09ecf19..8e08cb6 100644
--- a/lib/linux_admin/exceptions.rb
+++ b/lib/linux_admin/exceptions.rb
@@ -1 +1,8 @@
-  class CommandError < RuntimeError; end
+class CommandResultError < StandardError
+  attr_reader :result
+
+  def initialize(message, result)
+    super(message)
+    @result = result
+  end
+end
\ No newline at end of file
diff --git a/lib/linux_admin/logical_volume.rb b/lib/linux_admin/logical_volume.rb
index ae009cd..9379d0f 100644
--- a/lib/linux_admin/logical_volume.rb
+++ b/lib/linux_admin/logical_volume.rb
@@ -33,14 +33,14 @@ def initialize(args = {})
     end
 
     def extend_with(vg)
-      run(cmd(:lvextend),
+      run!(cmd(:lvextend),
           :params => [self.name, vg.name])
       self
     end
 
     def self.create(name, vg, size)
       self.scan # initialize local logical volumes
-      run(cmd(:lvcreate),
+      run!(cmd(:lvcreate),
           :params => { '-n' => name, nil => vg.name, '-L' => size})
       lv = LogicalVolume.new :name => name,
                              :volume_group => vg,
@@ -54,9 +54,7 @@ def self.scan
         vgs = VolumeGroup.scan
         lvs = []
 
-        out = run(cmd(:lvdisplay),
-                  :return_output => true,
-                  :params => { '-c' => nil})
+        out = run!(cmd(:lvdisplay), :params => { '-c' => nil}).output
 
         out.each_line do |line|
           fields = line.split(':')
diff --git a/lib/linux_admin/partition.rb b/lib/linux_admin/partition.rb
index 3b5411b..892c2c4 100644
--- a/lib/linux_admin/partition.rb
+++ b/lib/linux_admin/partition.rb
@@ -31,7 +31,7 @@ def path
     end
 
     def format_to(filesystem)
-      run(cmd(:mke2fs),
+      run!(cmd(:mke2fs),
           :params => { '-t' => filesystem, nil => self.path})
       @fs_type = filesystem
     end
@@ -42,12 +42,12 @@ def mount(mount_point=nil)
         "/mnt/#{disk.path.split(File::SEPARATOR).last}#{id}" if mount_point.nil?
       FileUtils.mkdir(@mount_point) unless File.directory?(@mount_point)
 
-      run(cmd(:mount),
+      run!(cmd(:mount),
           :params => { nil => [self.path, @mount_point] })
     end
 
     def umount
-      run(cmd(:umount),
+      run!(cmd(:umount),
           :params => { nil => [@mount_point] })
     end
   end
diff --git a/lib/linux_admin/physical_volume.rb b/lib/linux_admin/physical_volume.rb
index b919371..863f203 100644
--- a/lib/linux_admin/physical_volume.rb
+++ b/lib/linux_admin/physical_volume.rb
@@ -31,7 +31,7 @@ def initialize(args = {})
     end
 
     def attach_to(vg)
-      run(cmd(:vgextend),
+      run!(cmd(:vgextend),
           :params => [vg.name, @device_name])
       self.volume_group = vg
       self
@@ -40,7 +40,7 @@ def attach_to(vg)
     # specify disk or partition instance to create physical volume on
     def self.create(device)
       self.scan # initialize local physical volumes
-      run(cmd(:pvcreate),
+      run!(cmd(:pvcreate),
           :params => { nil => device.path})
       pv  = PhysicalVolume.new(:device_name  => device.path,
                                :volume_group => nil,
@@ -54,9 +54,7 @@ def self.scan
         vgs = VolumeGroup.scan
         pvs = []
 
-        out = run(cmd(:pvdisplay),
-                  :return_output => true,
-                  :params => { '-c' => nil})
+        out = run!(cmd(:pvdisplay), :params => { '-c' => nil}).output
 
         out.each_line do |line|
           fields = line.split(':')
diff --git a/lib/linux_admin/registration_system/rhn.rb b/lib/linux_admin/registration_system/rhn.rb
index 04511df..07ded11 100644
--- a/lib/linux_admin/registration_system/rhn.rb
+++ b/lib/linux_admin/registration_system/rhn.rb
@@ -29,7 +29,7 @@ def register(options)
       params["--proxyPassword="]  = options[:proxy_password]  if options[:proxy_password]
       params["--serverUrl="]      = options[:server_url]      if options[:server_url]
 
-      run(cmd, :params => params)
+      run!(cmd, :params => params)
     end
 
     def subscribe(options)
@@ -43,7 +43,7 @@ def subscribe(options)
       params["--password="] = options[:password]
       params                = params.to_a + pools
 
-      run(cmd, :params => params)
+      run!(cmd, :params => params)
     end
 
     private
diff --git a/lib/linux_admin/registration_system/subscription_manager.rb b/lib/linux_admin/registration_system/subscription_manager.rb
index cde67e3..984b1c6 100644
--- a/lib/linux_admin/registration_system/subscription_manager.rb
+++ b/lib/linux_admin/registration_system/subscription_manager.rb
@@ -8,11 +8,11 @@ def validate_credentials(options)
     end
 
     def registered?
-      run("subscription-manager identity", :return_exitstatus => true) == 0
+      run("subscription-manager identity").exit_status == 0
     end
 
     def refresh
-      run("subscription-manager refresh")
+      run!("subscription-manager refresh")
     end
 
     def organizations(options)
@@ -23,7 +23,7 @@ def organizations(options)
       params.merge!(proxy_params(options))
       params["--serverurl="]  = options[:server_url]  if options[:server_url]
 
-      output = run(cmd, :params => params, :return_output => true)
+      output = run!(cmd, :params => params).output
       parse_output(output).index_by {|i| i[:name]}
     end
 
@@ -36,7 +36,7 @@ def register(options)
       params["--org="]        = options[:org]         if options[:server_url] && options[:org]
       params["--serverurl="]  = options[:server_url]  if options[:server_url]
 
-      run(cmd, :params => params)
+      run!(cmd, :params => params)
     end
 
     def subscribe(options)
@@ -44,12 +44,12 @@ def subscribe(options)
       pools  = options[:pools].collect {|pool| ["--pool", pool]}
       params = proxy_params(options).to_a + pools
 
-      run(cmd, :params => params)
+      run!(cmd, :params => params)
     end
 
     def available_subscriptions
       cmd     = "subscription-manager list --all --available"
-      output  = run(cmd, :return_output => true)
+      output  = run!(cmd).output
       parse_output(output).index_by {|i| i[:pool_id]}
     end
 
diff --git a/lib/linux_admin/rpm.rb b/lib/linux_admin/rpm.rb
index 51e52e1..129b08e 100644
--- a/lib/linux_admin/rpm.rb
+++ b/lib/linux_admin/rpm.rb
@@ -1,7 +1,7 @@
 class LinuxAdmin
   class Rpm < LinuxAdmin
     def self.list_installed
-      out = run("rpm -qa --qf \"%{NAME} %{VERSION}-%{RELEASE}\n\"", :return_output => true)
+      out = run!("rpm -qa --qf \"%{NAME} %{VERSION}-%{RELEASE}\n\"").output
       out.split("\n").each_with_object({}) do |line, pkg_hash|
         name, ver = line.split(" ")
         pkg_hash[name] = ver
diff --git a/lib/linux_admin/service.rb b/lib/linux_admin/service.rb
index c4d1eb9..9deadb3 100644
--- a/lib/linux_admin/service.rb
+++ b/lib/linux_admin/service.rb
@@ -13,30 +13,29 @@ def initialize(id)
 
     def running?
       run(cmd(:service),
-          :params => { nil => [id, "status"] },
-          :return_exitstatus => true) == 0
+          :params => { nil => [id, "status"] }).exit_status == 0
     end
 
     def enable
-      run(cmd(:systemctl),
+      run!(cmd(:systemctl),
           :params => { nil => ["enable", "#{id}.service"] })
       self
     end
 
     def disable
-      run(cmd(:systemctl),
+      run!(cmd(:systemctl),
           :params => { nil => ["disable", "#{id}.service"] })
       self
     end
 
     def start
-      run(cmd(:service),
+      run!(cmd(:service),
           :params => { nil => [id, "start"] })
       self
     end
 
     def stop
-      run(cmd(:service),
+      run!(cmd(:service),
           :params => { nil => [id, "stop"] })
       self
     end
@@ -44,8 +43,7 @@ def stop
     def restart
       status =
         run(cmd(:service),
-          :params => { nil => [id, "restart"] },
-          :return_exitstatus => true)
+          :params => { nil => [id, "restart"] }).exit_status
 
       # attempt to manually stop/start if restart fails
       if status != 0
diff --git a/lib/linux_admin/system.rb b/lib/linux_admin/system.rb
index a137f1a..e149922 100644
--- a/lib/linux_admin/system.rb
+++ b/lib/linux_admin/system.rb
@@ -6,12 +6,12 @@
 class LinuxAdmin
   class System < LinuxAdmin
     def self.reboot!
-      run(cmd(:shutdown),
+      run!(cmd(:shutdown),
           :params => { "-r" => "now" })
     end
 
     def self.shutdown!
-      run(cmd(:shutdown),
+      run!(cmd(:shutdown),
           :params => { "-h" => "0" })
     end
   end
diff --git a/lib/linux_admin/volume_group.rb b/lib/linux_admin/volume_group.rb
index ba838a6..7412c9d 100644
--- a/lib/linux_admin/volume_group.rb
+++ b/lib/linux_admin/volume_group.rb
@@ -31,13 +31,13 @@ def initialize(args = {})
     end
 
     def attach_to(lv)
-      run(cmd(:lvextend),
+      run!(cmd(:lvextend),
           :params => [lv.name, self.name])
       self
     end
 
     def extend_with(pv)
-      run(cmd(:vgextend),
+      run!(cmd(:vgextend),
           :params => [@name, pv.device_name])
       pv.volume_group = self
       self
@@ -45,7 +45,7 @@ def extend_with(pv)
 
     def self.create(name, pv)
       self.scan # initialize local volume groups
-      run(cmd(:vgcreate),
+      run!(cmd(:vgcreate),
           :params => [name, pv.device_name])
       vg = VolumeGroup.new :name => name
       pv.volume_group = vg
@@ -57,9 +57,7 @@ def self.scan
       @vgs ||= begin
         vgs = []
 
-        out = run(cmd(:vgdisplay),
-                  :return_output => true,
-                  :params => { '-c' => nil})
+        out = run!(cmd(:vgdisplay), :params => { '-c' => nil}).output
 
         out.each_line do |line|
           fields = line.split(':')
diff --git a/lib/linux_admin/yum.rb b/lib/linux_admin/yum.rb
index eae31d3..a0ce717 100644
--- a/lib/linux_admin/yum.rb
+++ b/lib/linux_admin/yum.rb
@@ -14,7 +14,7 @@ def self.create_repo(path, options = {})
       params["--database"]            = nil  if options[:database]
       params["--unique-md-filenames"] = nil  if options[:unique_file_names]
 
-      run(cmd, :params => params)
+      run!(cmd, :params => params)
     end
 
     def self.download_packages(path, packages, options = {})
@@ -32,7 +32,7 @@ def self.download_packages(path, packages, options = {})
       params["-a"]  = options[:arch] if options[:arch]
       params[nil]   = packages
 
-      run(cmd, :params => params)
+      run!(cmd, :params => params)
     end
 
     def self.repo_settings
@@ -43,7 +43,7 @@ def self.updates_available?(*packages)
       cmd    = "yum check-update"
       params = {nil => packages} unless packages.blank?
 
-      exitstatus = run(cmd, :params => params, :return_exitstatus => true)
+      exitstatus = run(cmd, :params => params).exit_status
       case exitstatus
       when 0;   false
       when 100; true
@@ -55,7 +55,7 @@ def self.update(*packages)
       cmd    = "yum -y update"
       params = {nil => packages} unless packages.blank?
 
-      run(cmd, :params => params)
+      run!(cmd, :params => params)
     end
 
     def self.version_available(*packages)
@@ -64,7 +64,7 @@ def self.version_available(*packages)
       cmd    = "repoquery --qf=\"%{name} %{version}\""
       params = {nil => packages}
 
-      out = run(cmd, :params => params, :return_output => true)
+      out = run!(cmd, :params => params).output
 
       items = out.split("\n")
       items.each_with_object({}) do |i, versions|
diff --git a/spec/common_spec.rb b/spec/common_spec.rb
index 8b0b902..634c67c 100644
--- a/spec/common_spec.rb
+++ b/spec/common_spec.rb
@@ -30,85 +30,115 @@ class TestClass
   context ".cmd" do
     it "looks up local command from id" do
       d = double(LinuxAdmin::Distro)
-      d.class::COMMANDS = { :sh => '/bin/sh' }
+      d.class::COMMANDS = {:sh => '/bin/sh'}
       LinuxAdmin::Distro.should_receive(:local).and_return(d)
       subject.cmd(:sh).should == '/bin/sh'
     end
   end
 
-  context ".run" do
+  shared_examples_for "run" do
     context "with params" do
+      before do
+        subject.stub(:exitstatus => 0)
+      end
+
       it "sanitizes crazy params" do
         subject.should_receive(:launch).once.with("true --user bob --pass P@\\$sw0\\^\\&\\ \\|\\<\\>/-\\+\\*d\\% --db --desc=Some\\ Description pkg1 some\\ pkg --pool 123 --pool 456", {})
-        subject.run("true", :params => modified_params, :return_exitstatus => true)
+        subject.send(run_method, "true", :params => modified_params)
       end
 
       it "as empty hash" do
         subject.should_receive(:launch).once.with("true", {})
-        subject.run("true", :params => {}, :return_exitstatus => true)
+        subject.send(run_method, "true", :params => {})
       end
 
       it "as nil" do
         subject.should_receive(:launch).once.with("true", {})
-        subject.run("true", :params => nil, :return_exitstatus => true)
+        subject.send(run_method, "true", :params => nil)
       end
 
       it "won't modify caller params" do
         orig_params = params.dup
-        subject.run("true", :params => params, :return_exitstatus => true)
+        subject.stub(:launch)
+        subject.send(run_method, "true", :params => params)
         expect(orig_params).to eq(params)
       end
+
+      it "supports spawn's chdir option" do
+        subject.should_receive(:launch).once.with("true", {:chdir => ".."})
+        subject.send(run_method, "true", :chdir => "..")
+      end
     end
 
     context "with real execution" do
       before do
-        Kernel.should_receive(:spawn).and_call_original
+        Kernel.stub(:spawn).and_call_original
       end
 
       it "command ok exit ok" do
-        expect(subject.run("true")).to be_true
+        expect(subject.send(run_method, "true")).to be_kind_of CommandResult
       end
 
       it "command ok exit bad" do
-        expect { subject.run("false") }.to raise_error(CommandError)
+        if run_method == "run!"
+          error = nil
+
+          # raise_error with do/end block notation is broken in rspec-expectations 2.14.x
+          # and has been fixed in master but not yet released.
+          # See: https://github.com/rspec/rspec-expectations/commit/b0df827f4c12870aa4df2f20a817a8b01721a6af
+          expect {subject.send(run_method, "false")}.to raise_error {|e| error = e }
+          expect(error).to be_kind_of CommandResultError
+          expect(error.result).to be_kind_of CommandResult
+        else
+          expect {subject.send(run_method, "false")}.to_not raise_error
+        end
       end
 
       it "command bad" do
-        expect { subject.run("XXXXX") }.to raise_error(Errno::ENOENT)
+        expect {subject.send(run_method, "XXXXX")}.to raise_error(Errno::ENOENT)
       end
 
-      context "with :return_exitstatus => true" do
+      context "#exit_status" do
         it "command ok exit ok" do
-          expect(subject.run("true", :return_exitstatus => true)).to eq(0)
+          expect(subject.send(run_method, "true").exit_status).to eq(0)
         end
 
         it "command ok exit bad" do
-          expect(subject.run("false", :return_exitstatus => true)).to eq(1)
-        end
-
-        it "command bad" do
-          expect(subject.run("XXXXX", :return_exitstatus => true)).to be_nil
+          expect(subject.send(run_method, "false").exit_status).to eq(1) if run_method == "run"
         end
       end
 
-      context "with :return_output => true" do
+      context "#output" do
         it "command ok exit ok" do
-          expect(subject.run("echo \"Hello World\"", :return_output => true)).to eq("Hello World\n")
+          expect(subject.send(run_method, "echo \"Hello World\"").output).to eq("Hello World\n")
         end
 
         it "command ok exit bad" do
-          expect { subject.run("false", :return_output => true) }.to raise_error(CommandError)
+          expect(subject.send(run_method, "echo 'bad' && false").output).to eq("bad\n") if run_method == "run"
         end
+      end
 
-        it "command bad" do
-          expect { subject.run("XXXXX", :return_output => true) }.to raise_error(Errno::ENOENT)
+      context "#error" do
+        it "command ok exit ok" do
+          expect(subject.send(run_method, "echo \"Hello World\" >&2").error).to eq("Hello World\n")
+        end
+
+        it "command ok exit bad" do
+          expect(subject.send(run_method, "echo 'bad' >&2 && false").error).to eq("bad\n") if run_method == "run"
         end
       end
     end
+  end
+
+  context ".run" do
+    include_examples "run" do
+      let(:run_method) {"run"}
+    end
+  end
 
-    it "supports spawn's chdir option" do
-      subject.should_receive(:launch).once.with("true", {:chdir => ".."})
-      subject.run("true", :chdir => "..", :return_exitstatus => true)
+  context ".run!" do
+    include_examples "run" do
+      let(:run_method) {"run!"}
     end
   end
 end
diff --git a/spec/disk_spec.rb b/spec/disk_spec.rb
index 0ee22a8..a5cc1c8 100644
--- a/spec/disk_spec.rb
+++ b/spec/disk_spec.rb
@@ -15,11 +15,10 @@
   describe "#size" do
     it "uses fdisk" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      disk.should_receive(:run).
+      disk.should_receive(:run!).
         with(disk.cmd(:fdisk),
-             :return_output => true,
              :params => {"-l" => nil}).
-        and_return("")
+        and_return(double(:output => ""))
       disk.size
     end
 
@@ -39,7 +38,7 @@
 eos
 
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      disk.stub(:run).and_return(fdisk)
+      disk.stub(:run!).and_return(double(:output => fdisk))
       disk.size.should == 500.1.gigabytes
     end
   end
@@ -49,9 +48,7 @@
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
       disk.should_receive(:run).
         with(disk.cmd(:parted),
-             :return_exitstatus => true,
-             :return_output => true,
-             :params => { nil => ['/dev/hda', 'print'] }).and_return ""
+             :params => { nil => ['/dev/hda', 'print'] }).and_return(double(:output => ""))
       disk.partitions
     end
 
@@ -76,7 +73,7 @@
  3      162GB   163GB   1074MB  logical   linux-swap(v1)
 eos
       disk = LinuxAdmin::Disk.new
-      disk.should_receive(:run).and_return(partitions)
+      disk.should_receive(:run).and_return(double(:output => partitions))
 
       disk.partitions[0].id.should == 1
       disk.partitions[0].disk.should == disk
@@ -112,32 +109,32 @@
     end
 
     it "uses parted" do
-      @disk.should_receive(:run).
+      @disk.should_receive(:run!).
         with(@disk.cmd(:parted),
              :params => { nil => ['/dev/hda', 'mkpart', 'primary', 1024, 2048] })
       @disk.create_partition 'primary', 1024
     end
 
     it "returns partition" do
-      @disk.should_receive(:run) # stub out call to parted
+      @disk.should_receive(:run!) # stub out call to parted
       partition = @disk.create_partition 'primary', 1024
       partition.should be_an_instance_of(LinuxAdmin::Partition)
     end
 
     it "increments partition id" do
-      @disk.should_receive(:run) # stub out call to parted
+      @disk.should_receive(:run!) # stub out call to parted
       partition = @disk.create_partition 'primary', 1024
       partition.id.should == 2
     end
 
     it "sets partition start to first unused sector on disk" do
-      @disk.should_receive(:run) # stub out call to parted
+      @disk.should_receive(:run!) # stub out call to parted
       partition = @disk.create_partition 'primary', 1024
       partition.start_sector.should == 1024
     end
 
     it "stores new partition locally" do
-      @disk.should_receive(:run) # stub out call to parted
+      @disk.should_receive(:run!) # stub out call to parted
       lambda {
         @disk.create_partition 'primary', 1024
       }.should change{@disk.partitions.size}.by(1)
@@ -147,15 +144,17 @@
   describe "#clear!" do
     it "clears partitions" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      disk.stub(:run).and_return("") # stub out call to cmds
+      disk.should_receive(:run).and_return(double(:output => "")) # stub out call to cmds
       disk.partitions << LinuxAdmin::Partition.new
+
+      disk.should_receive(:run!)
       disk.clear!
       disk.partitions.should be_empty
     end
 
     it "uses dd to clear partition table" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      disk.should_receive(:run).
+      disk.should_receive(:run!).
            with(disk.cmd(:dd),
                 :params => {'if=' => '/dev/zero', 'of=' => '/dev/hda',
                             'bs=' => 512, 'count=' => 1})
@@ -164,7 +163,7 @@
 
     it "returns self" do
       disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      disk.stub(:run) # stub out call to dd
+      disk.stub(:run!) # stub out call to dd
       disk.clear!.should == disk
     end
   end
diff --git a/spec/logical_volume_spec.rb b/spec/logical_volume_spec.rb
index 2eaec19..7c60bef 100644
--- a/spec/logical_volume_spec.rb
+++ b/spec/logical_volume_spec.rb
@@ -25,7 +25,7 @@
     it "uses lvextend" do
       lv = described_class.new :name => 'lv'
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
-      lv.should_receive(:run).
+      lv.should_receive(:run!).
          with(vg.cmd(:lvextend),
               :params => ['lv', 'vg'])
       lv.extend_with(vg)
@@ -34,7 +34,7 @@
     it "returns self" do
       lv = described_class.new :name => 'lv'
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
-      lv.stub(:run)
+      lv.stub(:run!)
       lv.extend_with(vg).should == lv
     end
   end
@@ -46,7 +46,7 @@
 
     it "uses lvcreate" do
       described_class.instance_variable_set(:@lvs, [])
-      described_class.should_receive(:run).
+      described_class.should_receive(:run!).
                                 with(LinuxAdmin.cmd(:lvcreate),
                                      :params => { '-n' => 'lv',
                                                    nil => 'vg',
@@ -55,16 +55,16 @@
     end
 
     it "returns new logical volume" do
-      LinuxAdmin::VolumeGroup.stub(:run => "")
-      described_class.stub(:run => "")
+      LinuxAdmin::VolumeGroup.stub(:run! => double(:output => ""))
+      described_class.stub(:run! => double(:output => ""))
       lv = described_class.create 'lv', @vg, '256G'
       lv.should be_an_instance_of(described_class)
       lv.name.should == 'lv'
     end
 
     it "adds logical volume to local registry" do
-      LinuxAdmin::VolumeGroup.stub(:run => "")
-      described_class.stub(:run => "")
+      LinuxAdmin::VolumeGroup.stub(:run! => double(:output => ""))
+      described_class.stub(:run! => double(:output => ""))
       lv = described_class.create 'lv', @vg, '256G'
       described_class.scan.should include(lv)
     end
@@ -72,18 +72,17 @@
 
   describe "#scan" do
     it "uses lvdisplay" do
-      described_class.should_receive(:run).
+      described_class.should_receive(:run!).
                                 with(LinuxAdmin.cmd(:lvdisplay),
-                                     :return_output => true,
                                      :params => { '-c' => nil}).
-                                and_return(@logical_volumes)
-      LinuxAdmin::VolumeGroup.should_receive(:run).and_return(@groups) # stub out call to vgdisplay
+                                and_return(double(:output => @logical_volumes))
+      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups)) # stub out call to vgdisplay
       described_class.scan
     end
 
     it "returns local logical volumes" do
-      described_class.should_receive(:run).and_return(@logical_volumes)
-      LinuxAdmin::VolumeGroup.should_receive(:run).and_return(@groups)
+      described_class.should_receive(:run!).and_return(double(:output => @logical_volumes))
+      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups))
       lvs = described_class.scan
 
       lvs[0].should be_an_instance_of(described_class)
@@ -96,8 +95,8 @@
     end
 
     it "resolves volume group references" do
-      described_class.should_receive(:run).and_return(@logical_volumes)
-      LinuxAdmin::VolumeGroup.should_receive(:run).and_return(@groups)
+      described_class.should_receive(:run!).and_return(double(:output => @logical_volumes))
+      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups))
       lvs = described_class.scan
       lvs[0].volume_group.should be_an_instance_of(LinuxAdmin::VolumeGroup)
       lvs[0].volume_group.name.should == 'vg_foobar'
diff --git a/spec/partition_spec.rb b/spec/partition_spec.rb
index 7701315..416b7e0 100644
--- a/spec/partition_spec.rb
+++ b/spec/partition_spec.rb
@@ -7,7 +7,7 @@
 
     # stub out calls that modify system
     FileUtils.stub(:mkdir)
-    @partition.stub(:run)
+    @partition.stub(:run!)
   end
 
   describe "#path" do
@@ -18,14 +18,14 @@
 
   describe "#format_to" do
     it "uses mke2fs" do
-      @partition.should_receive(:run).
+      @partition.should_receive(:run!).
          with(@partition.cmd(:mke2fs),
               :params => { '-t' => 'ext4', nil => '/dev/sda2'})
       @partition.format_to('ext4')
     end
 
     it "sets fs type" do
-      @partition.should_receive(:run) # ignore actual formatting cmd
+      @partition.should_receive(:run!) # ignore actual formatting cmd
       @partition.format_to('ext4')
       @partition.fs_type.should == 'ext4'
     end
@@ -33,7 +33,7 @@
 
   describe "#mount" do
     it "sets mount point" do
-      @partition.should_receive(:run) # ignore actual mount cmd
+      @partition.should_receive(:run!) # ignore actual mount cmd
       @partition.mount
       @partition.mount_point.should == '/mnt/sda2'
     end
@@ -42,13 +42,13 @@
       it "creates mountpoint" do
         File.should_receive(:directory?).with('/mnt/sda2').and_return(false)
         FileUtils.should_receive(:mkdir).with('/mnt/sda2')
-        @partition.should_receive(:run) # ignore actual mount cmd
+        @partition.should_receive(:run!) # ignore actual mount cmd
         @partition.mount
       end
     end
 
     it "mounts partition" do
-      @partition.should_receive(:run).
+      @partition.should_receive(:run!).
          with(@partition.cmd(:mount),
               :params => { nil => ['/dev/sda2', '/mnt/sda2']})
       @partition.mount
@@ -58,7 +58,7 @@
   describe "#umount" do
     it "unmounts partition" do
       @partition.mount_point = '/mnt/sda2'
-      @partition.should_receive(:run).
+      @partition.should_receive(:run!).
          with(@partition.cmd(:umount),
               :params => { nil => ['/mnt/sda2']})
       @partition.umount
diff --git a/spec/physical_volume_spec.rb b/spec/physical_volume_spec.rb
index 3862ff9..9d40b05 100644
--- a/spec/physical_volume_spec.rb
+++ b/spec/physical_volume_spec.rb
@@ -24,7 +24,7 @@
     it "uses vgextend" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       pv = described_class.new :device_name => '/dev/hda'
-      pv.should_receive(:run).
+      pv.should_receive(:run!).
          with(pv.cmd(:vgextend),
               :params => ['vg', '/dev/hda'])
       pv.attach_to(vg)
@@ -33,7 +33,7 @@
     it "assigns volume group to physical volume" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       pv = described_class.new :device_name => '/dev/hda'
-      pv.stub(:run)
+      pv.stub(:run!)
       pv.attach_to(vg)
       pv.volume_group.should == vg
     end
@@ -41,7 +41,7 @@
     it "returns self" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       pv = described_class.new :device_name => '/dev/hda'
-      pv.stub(:run)
+      pv.stub(:run!)
       pv.attach_to(vg).should == pv
     end
   end
@@ -56,23 +56,23 @@
 
     it "uses pvcreate" do
       described_class.instance_variable_set(:@pvs, [])
-      described_class.should_receive(:run).
+      described_class.should_receive(:run!).
                                  with(LinuxAdmin.cmd(:pvcreate),
                                       :params => { nil => '/dev/hda'})
       described_class.create disk
     end
 
     it "returns new physical volume" do
-      LinuxAdmin::VolumeGroup.stub(:run => "")
-      described_class.stub(:run => "")
+      LinuxAdmin::VolumeGroup.stub(:run! => double(:output => ""))
+      described_class.stub(:run! => double(:output => ""))
       pv = described_class.create disk
       pv.should be_an_instance_of(described_class)
       pv.device_name.should == '/dev/hda'
     end
 
     it "adds physical volume to local registry" do
-      LinuxAdmin::VolumeGroup.stub(:run => "")
-      described_class.stub(:run => "")
+      LinuxAdmin::VolumeGroup.stub(:run! => double(:output => ""))
+      described_class.stub(:run! => double(:output => ""))
       pv = described_class.create disk
       described_class.scan.should include(pv)
     end
@@ -80,18 +80,17 @@
 
   describe "#scan" do
     it "uses pvdisplay" do
-      described_class.should_receive(:run).
+      described_class.should_receive(:run!).
                                  with(LinuxAdmin.cmd(:pvdisplay),
-                                     :return_output => true,
                                      :params => { '-c' => nil}).
-                                 and_return(@physical_volumes)
-      LinuxAdmin::VolumeGroup.should_receive(:run).and_return(@groups) # stub out call to vgdisplay
+                                 and_return(double(:output => @physical_volumes))
+      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups)) # stub out call to vgdisplay
       described_class.scan
     end
 
     it "returns local physical volumes" do
-      described_class.should_receive(:run).and_return(@physical_volumes)
-      LinuxAdmin::VolumeGroup.should_receive(:run).and_return(@groups)
+      described_class.should_receive(:run!).and_return(double(:output => @physical_volumes))
+      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups))
       pvs = described_class.scan
 
       pvs[0].should be_an_instance_of(described_class)
@@ -100,8 +99,8 @@
     end
 
     it "resolves volume group references" do
-      described_class.should_receive(:run).and_return(@physical_volumes)
-      LinuxAdmin::VolumeGroup.should_receive(:run).and_return(@groups)
+      described_class.should_receive(:run!).and_return(double(:output => @physical_volumes))
+      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups))
       pvs = described_class.scan
       pvs[0].volume_group.should be_an_instance_of(LinuxAdmin::VolumeGroup)
       pvs[0].volume_group.name.should == 'vg_foobar'
diff --git a/spec/registration_system_spec.rb b/spec/registration_system_spec.rb
index 52900e3..214acf1 100644
--- a/spec/registration_system_spec.rb
+++ b/spec/registration_system_spec.rb
@@ -18,13 +18,13 @@
     end
 
     it "should memoize results" do
-      described_class.should_receive(:registration_type_uncached).once.and_call_original
+      described_class.should_receive(:registration_type_uncached).once.and_return("anything_non_nil")
       described_class.registration_type
       described_class.registration_type
     end
 
     it "with reload should refresh results" do
-      described_class.should_receive(:registration_type_uncached).twice.and_call_original
+      described_class.should_receive(:registration_type_uncached).twice.and_return("anything_non_nil")
       described_class.registration_type
       described_class.registration_type(true)
     end
diff --git a/spec/rhn_spec.rb b/spec/rhn_spec.rb
index bc692a0..7e78ee9 100644
--- a/spec/rhn_spec.rb
+++ b/spec/rhn_spec.rb
@@ -24,7 +24,7 @@
     end
 
     it "with username and password" do
-      described_class.any_instance.should_receive(:run).once.with("rhnreg_ks", {:params=>{"--username="=>"SomeUser", "--password="=>"SomePass", "--proxy="=>"1.2.3.4", "--proxyUser="=>"ProxyUser", "--proxyPassword="=>"ProxyPass", "--serverUrl="=>"192.168.1.1"}}).and_return(0)
+      described_class.any_instance.should_receive(:run!).once.with("rhnreg_ks", {:params=>{"--username="=>"SomeUser", "--password="=>"SomePass", "--proxy="=>"1.2.3.4", "--proxyUser="=>"ProxyUser", "--proxyPassword="=>"ProxyPass", "--serverUrl="=>"192.168.1.1"}})
       described_class.new.register(
         :username       => "SomeUser",
         :password       => "SomePass",
@@ -36,7 +36,7 @@
     end
 
     it "with activation key" do
-      described_class.any_instance.should_receive(:run).once.with("rhnreg_ks", {:params=>{"--activationkey="=>"123abc", "--proxy="=>"1.2.3.4", "--proxyUser="=>"ProxyUser", "--proxyPassword="=>"ProxyPass", "--serverUrl="=>"192.168.1.1"}}).and_return(0)
+      described_class.any_instance.should_receive(:run!).once.with("rhnreg_ks", {:params=>{"--activationkey="=>"123abc", "--proxy="=>"1.2.3.4", "--proxyUser="=>"ProxyUser", "--proxyPassword="=>"ProxyPass", "--serverUrl="=>"192.168.1.1"}})
       described_class.new.register(
         :activationkey  => "123abc",
         :proxy_address  => "1.2.3.4",
@@ -53,7 +53,7 @@
     end
 
     it "with pools" do
-      described_class.any_instance.should_receive(:run).once.with("rhn-channel -a", {:params=>[["--user=", "SomeUser"], ["--password=", "SomePass"], ["--channel=", 123], ["--channel=", 456]]})
+      described_class.any_instance.should_receive(:run!).once.with("rhn-channel -a", {:params=>[["--user=", "SomeUser"], ["--password=", "SomePass"], ["--channel=", 123], ["--channel=", 456]]})
       described_class.new.subscribe({
         :username => "SomeUser",
         :password => "SomePass",
diff --git a/spec/rpm_spec.rb b/spec/rpm_spec.rb
index 9c06a2a..9d1691b 100644
--- a/spec/rpm_spec.rb
+++ b/spec/rpm_spec.rb
@@ -2,7 +2,7 @@
 
 describe LinuxAdmin::Rpm do
   it ".list_installed" do
-    described_class.stub(:run => sample_output("rpm/cmd_output_for_list_installed"))
+    described_class.stub(:run! => double(:output => sample_output("rpm/cmd_output_for_list_installed")))
     expect(described_class.list_installed).to eq({
       "ruby193-rubygem-some_really_long_name" =>"1.0.7-1.el6",
       "fipscheck-lib"                         =>"1.2.0-7.el6",
diff --git a/spec/service_spec.rb b/spec/service_spec.rb
index dee1767..18187d2 100644
--- a/spec/service_spec.rb
+++ b/spec/service_spec.rb
@@ -13,15 +13,14 @@
     it "checks service" do
       @service.should_receive(:run).
          with(@service.cmd(:service),
-              :params => { nil => ['foo', 'status']},
-              :return_exitstatus => true)
+              :params => { nil => ['foo', 'status']}).and_return(double(:exit_status => 0))
       @service.running?
     end
 
     context "service is running" do
       it "returns true" do
         @service = LinuxAdmin::Service.new :id => :foo
-        @service.should_receive(:run).and_return(0)
+        @service.should_receive(:run).and_return(double(:exit_status => 0))
         @service.should be_running
      end
     end
@@ -29,7 +28,7 @@
     context "service is not running" do
       it "returns false" do
         @service = LinuxAdmin::Service.new :id => :foo
-        @service.should_receive(:run).and_return(1)
+        @service.should_receive(:run).and_return(double(:exit_status => 1))
         @service.should_not be_running
       end
     end
@@ -37,56 +36,56 @@
 
   describe "#enable" do
     it "enables service" do
-      @service.should_receive(:run).
+      @service.should_receive(:run!).
          with(@service.cmd(:systemctl),
               :params => { nil => [ 'enable', 'foo.service']})
       @service.enable
     end
 
     it "returns self" do
-      @service.should_receive(:run) # stub out cmd invocation
+      @service.should_receive(:run!) # stub out cmd invocation
       @service.enable.should == @service
     end
   end
 
   describe "#disable" do
     it "disable service" do
-      @service.should_receive(:run).
+      @service.should_receive(:run!).
          with(@service.cmd(:systemctl),
               :params => { nil => [ 'disable', 'foo.service']})
       @service.disable
     end
 
     it "returns self" do
-      @service.should_receive(:run)
+      @service.should_receive(:run!)
       @service.disable.should == @service
     end
   end
 
   describe "#start" do
     it "starts service" do
-      @service.should_receive(:run).
+      @service.should_receive(:run!).
          with(@service.cmd(:service),
               :params => { nil => [ 'foo', 'start']})
       @service.start
     end
 
     it "returns self" do
-      @service.should_receive(:run)
+      @service.should_receive(:run!)
       @service.start.should == @service
     end
   end
 
   describe "#stop" do
     it "stops service" do
-      @service.should_receive(:run).
+      @service.should_receive(:run!).
          with(@service.cmd(:service),
               :params => { nil => [ 'foo', 'stop']})
       @service.stop
     end
 
     it "returns self" do
-      @service.should_receive(:run)
+      @service.should_receive(:run!)
       @service.stop.should == @service
     end
   end
@@ -95,14 +94,13 @@
     it "stops service" do
       @service.should_receive(:run).
          with(@service.cmd(:service),
-              :params => { nil => [ 'foo', 'restart']},
-              :return_exitstatus => true).and_return(0)
+              :params => { nil => [ 'foo', 'restart']}).and_return(double(:exit_status => 0))
       @service.restart
     end
 
     context "service restart fails" do
       it "manually stops/starts service" do
-        @service.should_receive(:run).and_return(1)
+        @service.should_receive(:run).and_return(double(:exit_status => 1))
         @service.should_receive(:stop)
         @service.should_receive(:start)
         @service.restart
@@ -110,7 +108,7 @@
     end
 
     it "returns self" do
-      @service.should_receive(:run).and_return(0)
+      @service.should_receive(:run).and_return(double(:exit_status => 0))
       @service.restart.should == @service
     end
   end
diff --git a/spec/subscription_manager_spec.rb b/spec/subscription_manager_spec.rb
index 4e009aa..d861d44 100644
--- a/spec/subscription_manager_spec.rb
+++ b/spec/subscription_manager_spec.rb
@@ -3,18 +3,18 @@
 describe LinuxAdmin::SubscriptionManager do
   context "#registered?" do
     it "system with subscription-manager commands" do
-      described_class.any_instance.should_receive(:run).once.with("subscription-manager identity", {:return_exitstatus=>true}).and_return(0)
+      described_class.any_instance.should_receive(:run).once.with("subscription-manager identity").and_return(double(:exit_status => 0))
       expect(described_class.new.registered?).to be_true
     end
 
     it "system without subscription-manager commands" do
-      described_class.any_instance.should_receive(:run).once.with("subscription-manager identity", {:return_exitstatus=>true}).and_return(255)
+      described_class.any_instance.should_receive(:run).once.with("subscription-manager identity").and_return(double(:exit_status => 255))
       expect(described_class.new.registered?).to be_false
     end
   end
 
   it "#refresh" do
-    described_class.any_instance.should_receive(:run).once.with("subscription-manager refresh").and_return(0)
+    described_class.any_instance.should_receive(:run!).once.with("subscription-manager refresh")
     described_class.new.refresh
   end
 
@@ -24,7 +24,8 @@
     end
 
     it "with username and password" do
-      described_class.any_instance.should_receive(:run).once.with("subscription-manager register", {:params=>{"--username="=>"SomeUser", "--password="=>"SomePass", "--org="=>"IT", "--proxy="=>"1.2.3.4", "--proxyuser="=>"ProxyUser", "--proxypassword="=>"ProxyPass", "--serverurl="=>"192.168.1.1"}}).and_return(0)
+      run_options = ["subscription-manager register", {:params=>{"--username="=>"SomeUser", "--password="=>"SomePass", "--org="=>"IT", "--proxy="=>"1.2.3.4", "--proxyuser="=>"ProxyUser", "--proxypassword="=>"ProxyPass", "--serverurl="=>"192.168.1.1"}}]
+      described_class.any_instance.should_receive(:run!).once.with(*run_options)
       described_class.new.register(
         :username       => "SomeUser",
         :password       => "SomePass",
@@ -38,12 +39,12 @@
   end
 
   it "#subscribe" do
-    described_class.any_instance.should_receive(:run).once.with("subscription-manager attach", {:params=>[["--pool", 123], ["--pool", 456]]})
+    described_class.any_instance.should_receive(:run!).once.with("subscription-manager attach", {:params=>[["--pool", 123], ["--pool", 456]]})
     described_class.new.subscribe({:pools => [123, 456]})
   end
 
   it "#available_subscriptions" do
-    described_class.any_instance.should_receive(:run).once.with("subscription-manager list --all --available", :return_output => true).and_return(sample_output("subscription_manager/output_list_all_available"))
+    described_class.any_instance.should_receive(:run!).once.with("subscription-manager list --all --available").and_return(double(:output => sample_output("subscription_manager/output_list_all_available")))
     expect(described_class.new.available_subscriptions).to eq({
       "82c042fca983889b10178893f29b06e3" => {
         :subscription_name => "Example Subscription",
@@ -93,7 +94,8 @@
   end
 
   it "#organizations" do
-    described_class.any_instance.should_receive(:run).once.with("subscription-manager orgs", {:params=>{"--username="=>"SomeUser", "--password="=>"SomePass", "--proxy="=>"1.2.3.4", "--proxyuser="=>"ProxyUser", "--proxypassword="=>"ProxyPass", "--serverurl="=>"192.168.1.1"}, :return_output => true}).and_return(sample_output("subscription_manager/output_orgs"))
+    run_options = ["subscription-manager orgs", {:params=>{"--username="=>"SomeUser", "--password="=>"SomePass", "--proxy="=>"1.2.3.4", "--proxyuser="=>"ProxyUser", "--proxypassword="=>"ProxyPass", "--serverurl="=>"192.168.1.1"}}]
+    described_class.any_instance.should_receive(:run!).once.with(*run_options).and_return(double(:output => sample_output("subscription_manager/output_orgs")))
     expect(described_class.new.organizations({:username=>"SomeUser", :password=>"SomePass", :proxy_address=>"1.2.3.4", :proxy_username=>"ProxyUser", :proxy_password=>"ProxyPass", :server_url=>"192.168.1.1"})).to eq({"SomeOrg"=>{:name=>"SomeOrg", :key=>"1234567"}})
   end
 end
diff --git a/spec/system_spec.rb b/spec/system_spec.rb
index 3d0f3a8..ab6a3f4 100644
--- a/spec/system_spec.rb
+++ b/spec/system_spec.rb
@@ -3,7 +3,7 @@
 describe LinuxAdmin::System do
   describe "#reboot!" do
     it "reboots the system" do
-      LinuxAdmin::System.should_receive(:run).
+      LinuxAdmin::System.should_receive(:run!).
          with(LinuxAdmin::System.cmd(:shutdown),
               :params => { '-r' => 'now'})
       LinuxAdmin::System.reboot!
@@ -12,7 +12,7 @@
 
   describe "#shutdown!" do
     it "shuts down the system" do
-      LinuxAdmin::System.should_receive(:run).
+      LinuxAdmin::System.should_receive(:run!).
          with(LinuxAdmin::System.cmd(:shutdown),
               :params => { '-h' => '0'})
       LinuxAdmin::System.shutdown!
diff --git a/spec/volume_group_spec.rb b/spec/volume_group_spec.rb
index 619d56d..fd3a079 100644
--- a/spec/volume_group_spec.rb
+++ b/spec/volume_group_spec.rb
@@ -20,7 +20,7 @@
     it "uses lvextend" do
       lv = LinuxAdmin::LogicalVolume.new :name => 'lv'
       vg = described_class.new :name => 'vg'
-      vg.should_receive(:run).
+      vg.should_receive(:run!).
          with(vg.cmd(:lvextend),
               :params => ['lv', 'vg'])
       vg.attach_to(lv)
@@ -29,7 +29,7 @@
     it "returns self" do
       lv = LinuxAdmin::LogicalVolume.new :name => 'lv'
       vg = described_class.new :name => 'vg'
-      vg.stub(:run)
+      vg.stub(:run!)
       vg.attach_to(lv).should == vg
     end
   end
@@ -38,7 +38,7 @@
     it "uses vgextend" do
       vg = described_class.new :name => 'vg'
       pv = LinuxAdmin::PhysicalVolume.new :device_name => '/dev/hda'
-      vg.should_receive(:run).
+      vg.should_receive(:run!).
          with(vg.cmd(:vgextend),
               :params => ['vg', '/dev/hda'])
       vg.extend_with(pv)
@@ -47,7 +47,7 @@
     it "assigns volume group to physical volume" do
       vg = described_class.new :name => 'vg'
       pv = LinuxAdmin::PhysicalVolume.new :device_name => '/dev/hda'
-      vg.stub(:run)
+      vg.stub(:run!)
       vg.extend_with(pv)
       pv.volume_group.should == vg
     end
@@ -55,7 +55,7 @@
     it "returns self" do
       vg = described_class.new :name => 'vg'
       pv = LinuxAdmin::PhysicalVolume.new :device_name => '/dev/hda'
-      vg.stub(:run)
+      vg.stub(:run!)
       vg.extend_with(pv).should == vg
     end
   end
@@ -67,21 +67,21 @@
 
     it "uses vgcreate" do
       described_class.instance_variable_set(:@vgs, [])
-      described_class.should_receive(:run).
+      described_class.should_receive(:run!).
                               with(LinuxAdmin.cmd(:vgcreate),
                                    :params => ['vg', '/dev/hda'])
       described_class.create 'vg', @pv
     end
 
     it "returns new volume group" do
-      described_class.stub(:run => "")
+      described_class.stub(:run! => double(:output => ""))
       vg = described_class.create 'vg', @pv
       vg.should be_an_instance_of(described_class)
       vg.name.should == 'vg'
     end
 
     it "adds volume group to local registry" do
-      described_class.stub(:run => "")
+      described_class.stub(:run! => double(:output => ""))
       vg = described_class.create 'vg', @pv
       described_class.scan.should include(vg)
     end
@@ -89,16 +89,15 @@
 
   describe "#scan" do
     it "uses vgdisplay" do
-      described_class.should_receive(:run).
+      described_class.should_receive(:run!).
                               with(LinuxAdmin.cmd(:vgdisplay),
-                                   :return_output => true,
                                    :params => { '-c' => nil}).
-                                 and_return(@groups)
+                                 and_return(double(:output => @groups))
       described_class.scan
     end
 
     it "returns local volume groups" do
-      described_class.should_receive(:run).and_return(@groups)
+      described_class.should_receive(:run!).and_return(double(:output => @groups))
       vgs = described_class.scan
 
       vgs[0].should be_an_instance_of(described_class)
diff --git a/spec/yum_spec.rb b/spec/yum_spec.rb
index 908045c..53e77b2 100644
--- a/spec/yum_spec.rb
+++ b/spec/yum_spec.rb
@@ -7,20 +7,20 @@
 
   context ".create_repo" do
     it "default arguments" do
-      described_class.should_receive(:run).once.with("yum createrepo", {:params=>{nil=>"some/path", "--database"=>nil, "--unique-md-filenames"=>nil}}).and_return true
-      expect(described_class.create_repo("some/path")).to be_true
+      described_class.should_receive(:run!).once.with("yum createrepo", {:params=>{nil=>"some/path", "--database"=>nil, "--unique-md-filenames"=>nil}})
+      described_class.create_repo("some/path")
     end
 
     it "bare create" do
-      described_class.should_receive(:run).once.with("yum createrepo", {:params=>{nil=>"some/path"}}).and_return true
-      expect(described_class.create_repo("some/path", :database => false, :unique_file_names => false)).to be_true
+      described_class.should_receive(:run!).once.with("yum createrepo", {:params=>{nil=>"some/path"}})
+      described_class.create_repo("some/path", :database => false, :unique_file_names => false)
     end
   end
 
   context ".download_packages" do
     it "with valid input" do
-      described_class.should_receive(:run).once.with("yum repotrack", {:params=>{"-p"=>"some/path", nil=>"pkg_a pkg_b"}}).and_return true
-      expect(described_class.download_packages("some/path", "pkg_a pkg_b")).to be_true
+      described_class.should_receive(:run!).once.with("yum repotrack", {:params=>{"-p"=>"some/path", nil=>"pkg_a pkg_b"}})
+      described_class.download_packages("some/path", "pkg_a pkg_b")
     end
 
     it "without mirror type" do
@@ -68,39 +68,39 @@
 
   context ".updates_available?" do
     it "check updates for a specific package" do
-      described_class.should_receive(:run).once.with("yum check-update", {:params=>{nil=>["abc"]}, :return_exitstatus=>true}).and_return(100)
+      described_class.should_receive(:run).once.with("yum check-update", {:params=>{nil=>["abc"]}}).and_return(double(:exit_status => 100))
       expect(described_class.updates_available?("abc")).to be_true
     end
 
     it "updates are available" do
-      described_class.stub(:run => 100)
+      described_class.stub(:run => double(:exit_status => 100))
       expect(described_class.updates_available?).to be_true
     end
 
     it "updates not available" do
-      described_class.stub(:run => 0)
+      described_class.stub(:run => double(:exit_status => 0))
       expect(described_class.updates_available?).to be_false
     end
 
     it "other exit code" do
-      described_class.stub(:run => 255)
+      described_class.stub(:run => double(:exit_status => 255))
       expect { described_class.updates_available? }.to raise_error
     end
 
     it "other error" do
       described_class.stub(:run).and_raise(RuntimeError)
-      expect { described_class.updates_available? }.to raise_error
+      expect { described_class.updates_available? }.to raise_error(RuntimeError)
     end
   end
 
   context ".update" do
     it "no arguments" do
-      described_class.should_receive(:run).once.with("yum -y update", {:params=>nil}).and_return(0)
+      described_class.should_receive(:run!).once.with("yum -y update", {:params=>nil})
       described_class.update
     end
 
     it "with arguments" do
-      described_class.should_receive(:run).once.with("yum -y update", {:params=>{nil=>["1 2", "3"]}}).and_return(0)
+      described_class.should_receive(:run!).once.with("yum -y update", {:params=>{nil=>["1 2", "3"]}})
       described_class.update("1 2", "3")
     end
   end
@@ -111,7 +111,7 @@
     end
 
     it "with packages" do
-      described_class.should_receive(:run).once.with("repoquery --qf=\"%{name} %{version}\"", {:params=>{nil=>["curl"]}, :return_output=>true}).and_return(sample_output("yum/output_repoquery"))
+      described_class.should_receive(:run!).once.with("repoquery --qf=\"%{name} %{version}\"", {:params=>{nil=>["curl"]}}).and_return(double(:output => sample_output("yum/output_repoquery")))
       expect(described_class.version_available("curl")).to eq({
         "curl"                  => "7.19.7",
         "subscription-manager"  => "1.1.23.1",