mcollective-client 1.3.3 → 2.0.0

data/spec/unit/pluginpackager/standard_definition_spec.rb

@@ -9,9 +9,22 @@ module MCollective
         PluginPackager.expects(:get_metadata).once.returns({:name => "foo"})
       end
 
-      it "should replace spaces in the package name with underscores" do
-        plugin = StandardDefinition.new(".", "test plugin", nil, nil, nil, :fooplugin)
-        plugin.metadata[:name].should == "test_plugin"
+      describe "#initialize" do
+        it "should replace spaces in the package name with dashes" do
+          plugin = StandardDefinition.new(".", "test plugin", nil, nil, nil, nil, [], {}, "testplugin")
+          plugin.metadata[:name].should == "test-plugin"
+        end
+
+        it "should set dependencies if present" do
+          plugin = StandardDefinition.new(".", "test plugin", nil, nil, nil, nil, ["foo"], {}, "testplugin")
+          plugin.dependencies.should == ["foo"]
+        end
+
+        it "should set mc server, client and common dependencies" do
+          plugin = StandardDefinition.new(".", "test plugin", nil, nil, nil, nil, [], {:server => "pe-mcollective"}, "testplugin")
+          plugin.mcserver.should == "pe-mcollective"
+          plugin.mccommon.should == "mcollective-common"
+        end
       end
 
       describe "#identify_packages" do
@@ -19,9 +32,9 @@ module MCollective
           StandardDefinition.any_instance.expects(:common).once.returns(:check)
           StandardDefinition.any_instance.expects(:plugin).once.returns(:check)
 
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, :fooplugin)
+          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
           plugin.packagedata[:common].should == :check
-          plugin.packagedata[:fooplugin].should == :check
+          plugin.packagedata["testplugin"].should == :check
         end
       end
 
@@ -30,25 +43,25 @@ module MCollective
         it "should return nil if the plugin doesn't contain any files" do
           StandardDefinition.any_instance.expects(:common).returns(nil)
           PluginPackager.expects(:check_dir_present).returns(false)
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, :fooplugin)
-          plugin.packagedata[:fooplugin].should == nil
+          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
+          plugin.packagedata["testplugin"].should == nil
         end
 
         it "should add plugin files to the file list" do
           StandardDefinition.any_instance.expects(:common).returns(nil)
           PluginPackager.expects(:check_dir_present).returns(true)
-          Dir.expects(:glob).with("./fooplugin/*").returns(["file.rb"])
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, :fooplugin)
-          plugin.packagedata[:fooplugin][:files].should == ["file.rb"]
+          Dir.expects(:glob).with("./testplugin/*").returns(["file.rb"])
+          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
+          plugin.packagedata["testplugin"][:files].should == ["file.rb"]
         end
 
         it "should add common package as dependency if present" do
           StandardDefinition.any_instance.expects(:common).returns(true)
           PluginPackager.expects(:check_dir_present).returns(true)
-          Dir.expects(:glob).with("./fooplugin/*").returns(["file.rb"])
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, :fooplugin)
-          plugin.packagedata[:fooplugin][:files].should == ["file.rb"]
-          plugin.packagedata[:fooplugin][:dependencies].should == ["mcollective", "mcollective-foo-common"]
+          Dir.expects(:glob).with("./testplugin/*").returns(["file.rb"])
+          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
+          plugin.packagedata["testplugin"][:files].should == ["file.rb"]
+          plugin.packagedata["testplugin"][:dependencies].should == ["mcollective", "mcollective-foo-common"]
         end
       end
 
@@ -59,14 +72,14 @@ module MCollective
 
         it "should return nil if common doesn't contain any files" do
           PluginPackager.expects(:check_dir_present).returns(false)
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, :fooplugin)
+          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
           plugin.packagedata[:common].should == nil
         end
 
         it "should add common files to the file list" do
           PluginPackager.expects(:check_dir_present).returns(true)
           Dir.expects(:glob).with("./util/*").returns(["common.rb"])
-          plugin = StandardDefinition.new(".", nil, nil, nil, nil, :fooplugin)
+          plugin = StandardDefinition.new(".", nil, nil, nil, nil, nil, [], {}, "testplugin")
           plugin.packagedata[:common][:files].should == ["common.rb"]
         end
       end

data/spec/unit/plugins/mcollective/packagers/debpackage_packager_spec.rb

@@ -0,0 +1,285 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/pluginpackager/debpackage_packager.rb'
+
+module MCollective
+  module PluginPackager
+    describe DebpackagePackager do
+
+      let(:maketmpdir) do
+        tmpdir = Dir.mktmpdir("mc-test")
+        @tmpdirs << tmpdir
+        tmpdir
+      end
+
+      before :all do
+        @tmpdirs = []
+      end
+
+      before :each do
+        PluginPackager.stubs(:build_tool?).with("debuild").returns(true)
+        @plugin = mock()
+      end
+
+      after :all do
+        @tmpdirs.each{|tmpdir| FileUtils.rm_rf tmpdir if File.directory? tmpdir}
+      end
+
+      describe "#initialize" do
+        it "should raise an exception if debuild isn't present" do
+          PluginPackager.expects(:build_tool?).with("debuild").returns(false)
+          expect{
+            DebpackagePackager.new("plugin")
+          }.to raise_error RuntimeError, "package 'debuild' is not installed"
+        end
+
+        it "should set the correct libdir and verbose value" do
+          PluginPackager.expects(:build_tool?).with("debuild").returns(true)
+          packager = DebpackagePackager.new("plugin", nil, nil, true)
+          packager.libdir.should == "/usr/share/mcollective/plugins/mcollective/"
+          packager.verbose.should == true
+        end
+      end
+
+      describe "#create_packages" do
+        before :each do
+          @packager = DebpackagePackager.new(@plugin)
+          @plugin.stubs(:packagedata).returns({:test => {:files => ["test.rb"]}})
+          @plugin.stubs(:metadata).returns({:name => "test_plugin", :version => "1"})
+          @plugin.stubs(:iteration).returns("1")
+          @packager.stubs(:prepare_tmpdirs)
+          @packager.stubs(:create_package)
+          @packager.stubs(:cleanup_tmpdirs)
+          Dir.stubs(:mktmpdir).with("mcollective_packager").returns("/tmp")
+          Dir.stubs(:mkdir)
+        end
+
+        it "should set the package instance variables" do
+          @packager.create_packages
+          @packager.current_package_type.should == :test
+          @packager.current_package_data.should == {:files => ["test.rb"]}
+          @packager.current_package_shortname.should == "mcollective-test_plugin-test"
+          @packager.current_package_fullname.should == "mcollective-test_plugin-test_1-1"
+        end
+
+        it "Should create the build dir" do
+          Dir.expects(:mkdir).with("/tmp/mcollective-test_plugin-test_1-1")
+          @packager.create_packages
+        end
+
+        it "should create packages" do
+          @packager.expects(:create_package)
+          @packager.create_packages
+        end
+      end
+
+      describe "#create_package" do
+        it "should raise an exception if the package cannot be created" do
+          packager = DebpackagePackager.new(@plugin)
+          packager.stubs(:create_file).raises("test exception")
+          expect{
+            packager.create_package
+          }.to raise_error RuntimeError, "Could not build package - test exception"
+        end
+
+        it "should correctly create a package" do
+          packager = DebpackagePackager.new(@plugin, nil, nil, true)
+
+          packager.expects(:create_file).with("control")
+          packager.expects(:create_file).with("Makefile")
+          packager.expects(:create_file).with("compat")
+          packager.expects(:create_file).with("rules")
+          packager.expects(:create_file).with("copyright")
+          packager.expects(:create_file).with("changelog")
+          packager.expects(:create_tar)
+          packager.expects(:create_install)
+          packager.expects(:create_preandpost_install)
+
+          packager.build_dir = "/tmp"
+          packager.tmpdir = "/tmp"
+          packager.current_package_fullname = "test"
+          PluginPackager.expects(:safe_system).with("debuild -i -us -uc")
+          FileUtils.expects(:cp).with(File.join("/tmp", "test_all.deb"), ".")
+          packager.expects(:puts).with("Created package test")
+
+          packager.create_package
+        end
+
+        it "should add a signature if one is given" do
+          packager = DebpackagePackager.new(@plugin, nil, "test", true)
+
+          packager.expects(:create_file).with("control")
+          packager.expects(:create_file).with("Makefile")
+          packager.expects(:create_file).with("compat")
+          packager.expects(:create_file).with("rules")
+          packager.expects(:create_file).with("copyright")
+          packager.expects(:create_file).with("changelog")
+          packager.expects(:create_tar)
+          packager.expects(:create_install)
+          packager.expects(:create_preandpost_install)
+
+          packager.build_dir = "/tmp"
+          packager.tmpdir = "/tmp"
+          packager.current_package_fullname = "test"
+          PluginPackager.expects(:safe_system).with("debuild -i -ktest")
+          FileUtils.expects(:cp).with(File.join("/tmp", "test_all.deb"), ".")
+          packager.expects(:puts).with("Created package test")
+
+          packager.create_package
+        end
+      end
+
+      describe "#create_preandpost_install" do
+        before :each do
+          @packager = DebpackagePackager.new(@plugin)
+        end
+
+        it "should raise an exception if preinstall is not null and preinstall script isn't present" do
+          @plugin.stubs(:preinstall).returns("myscript")
+          File.expects(:exists?).with("myscript").returns(false)
+          expect{
+            @packager.create_preandpost_install
+          }.to raise_error RuntimeError, "pre-install script 'myscript' not found"
+        end
+
+        it "should raise an exception if postinstall is not null and postinstall script isn't present" do
+          @plugin.stubs(:preinstall).returns(nil)
+          @plugin.stubs(:postinstall).returns("myscript")
+          File.expects(:exists?).with("myscript").returns(false)
+          expect{
+            @packager.create_preandpost_install
+          }.to raise_error RuntimeError, "post-install script 'myscript' not found"
+        end
+
+        it "should copy the preinstall and postinstall scripts to the correct directory with the correct name" do
+          @plugin.stubs(:postinstall).returns("myscript")
+          @plugin.stubs(:preinstall).returns("myscript")
+          @packager.build_dir = "/tmp/"
+          @packager.current_package_shortname = "test"
+          File.expects(:exists?).with("myscript").twice.returns(true)
+          FileUtils.expects(:cp).with("myscript", "/tmp/debian/test.preinst")
+          FileUtils.expects(:cp).with("myscript", "/tmp/debian/test.postinst")
+          @packager.create_preandpost_install
+        end
+      end
+
+      describe "#create_install" do
+        before :each do
+          @packager = DebpackagePackager.new(@plugin)
+        end
+
+        it "should raise an exception if the install file can't be created" do
+          File.expects(:join).raises("test error")
+          expect{
+            @packager.create_install
+          }.to raise_error RuntimeError, "Could not create install file - test error"
+        end
+
+        it "should copy the package install file to the correct location" do
+          tmpdir = maketmpdir
+          Dir.mkdir(File.join(tmpdir, "debian"))
+          @packager.build_dir = tmpdir
+          @packager.current_package_shortname = "test"
+          @packager.current_package_data = {:files => ["foo.rb"]}
+          @packager.create_install
+          install_file = File.read("#{tmpdir}/debian/test.install")
+          install_file.should == "/usr/share/mcollective/plugins/mcollective/foo.rb /usr/share/mcollective/plugins/mcollective/.\n"
+        end
+      end
+
+      describe "#create_tar" do
+        before :each do
+          @packager = DebpackagePackager.new(@plugin, nil, true)
+        end
+
+        it "should raise an exception if the tarball can't be built" do
+          PluginPackager.expects(:do_quietly?).raises("test error")
+          expect{
+            @packager.create_tar
+          }.to raise_error RuntimeError, "Could not create tarball - test error"
+        end
+
+        it "should create a tarball containing the package files" do
+          @packager.tmpdir = "/tmp"
+          @packager.build_dir = "/build_dir"
+          @packager.current_package_shortname = "test"
+          @plugin.stubs(:metadata).returns(@plugin)
+          @plugin.stubs(:[]).with(:version).returns("1")
+          @plugin.stubs(:iteration).returns("1")
+          PluginPackager.expects(:safe_system).with("tar -Pcvzf /tmp/test_1.orig.tar.gz /build_dir")
+          @packager.create_tar
+        end
+      end
+
+      describe "#create_file" do
+        before :each do
+          @packager = DebpackagePackager.new(@plugin)
+        end
+
+        it "should raise an exception if the file can't be created" do
+          File.expects(:dirname).raises("test error")
+          expect{
+            @packager.create_file("test")
+          }.to raise_error RuntimeError, "could not create test file - test error"
+        end
+
+        it "should place a build file in the debian directory" do
+          tmpdir = maketmpdir
+          Dir.mkdir(File.join(tmpdir, "debian"))
+          @packager.build_dir = tmpdir
+          File.expects(:read).returns("testfile")
+          @packager.create_file("testfile")
+          File.unstub(:read)
+          result = File.read(File.join(tmpdir, "debian", "testfile"))
+          result.stubs(:result)
+          result.should == "testfile\n"
+        end
+      end
+
+      describe "#prepare_tmpdirs" do
+        before :all do
+          @tmpfile = Tempfile.new("mc-file").path
+        end
+
+        after :all do
+          FileUtils.rm(@tmpfile)
+        end
+
+        it "should create the correct tmp dirs and copy package contents to correct dir" do
+          packager = DebpackagePackager.new(@plugin)
+          tmpdir = maketmpdir
+          packager.build_dir = tmpdir
+          @plugin.stubs(:target_path).returns("")
+
+          packager.prepare_tmpdirs({:files => [@tmpfile]})
+          File.directory?(tmpdir).should == true
+          File.directory?(File.join(tmpdir, "debian")).should == true
+          File.exists?(File.join(tmpdir, packager.libdir, "tmp", File.basename(@tmpfile))).should == true
+        end
+      end
+
+      describe "#cleanup_tmpdirs" do
+        before :all do
+          @tmpdir = maketmpdir
+        end
+
+        before :each do
+          @packager = DebpackagePackager.new(@plugin)
+        end
+
+        it "should cleanup temp directories" do
+          @packager.tmpdir = @tmpdir
+          @packager.cleanup_tmpdirs
+          File.directory?(@tmpdir).should == false
+        end
+
+        it "should not delete any directories if @tmpdir isn't present" do
+          @packager = DebpackagePackager.new(@plugin)
+          @packager.tmpdir = rand.to_s
+          FileUtils.expects(:rm_r).never
+          @packager.cleanup_tmpdirs
+        end
+      end
+    end
+  end
+end

data/spec/unit/plugins/mcollective/packagers/ospackage_spec.rb

@@ -7,222 +7,50 @@ require File.dirname(__FILE__) + '/../../../../../plugins/mcollective/pluginpack
 
 module MCollective
   module PluginPackager
-    describe OspackagePackager do
-      before :all do
-
-        class OspackagePackager
-          ENV = {"PATH" => "."}
-        end
-
-        class TestPlugin
-          attr_accessor :path, :packagedata, :metadata, :target_path, :vendor, :iteration
-          attr_accessor :postinstall
-
-          def initialize
-            @path = "/tmp"
-            @packagedata = {:testpackage => {:files => ["/tmp/test.rb"],
-                                             :dependencies => ["mcollective"],
-                                             :description => "testpackage"}}
-            @iteration = 1
-            @postinstall = "/tmp/test.sh"
-            @metadata = {:name => "testplugin",
-                         :description => "A Test Plugin",
-                         :author => "Psy",
-                         :license => "Apache 2",
-                         :version => "0",
-                         :url => "http://foo.bar.com",
-                         :timeout => 5}
-            @vendor = "Puppet Labs"
-            @target_path = "/tmp"
-          end
-        end
-
-        @testplugin = TestPlugin.new
-      end
-
-      describe "#initialize" do
-        it "should correctly identify a RedHat system" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(true)
-          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
-
-          ospackage = OspackagePackager.new(@testplugin)
-          ospackage.libdir.should == "usr/libexec/mcollective/mcollective/"
-          ospackage.package_type.should == "RPM"
-        end
-
-        it "should correctly identify a Debian System" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(false)
-          File.expects(:exists?).with("/etc/debian_version").returns(true)
-          OspackagePackager.any_instance.expects(:build_tool?).with("ar").returns(true)
+    describe "#initialize" do
 
-          ospackage = OspackagePackager.new(@testplugin)
-          ospackage.libdir.should == "usr/share/mcollective/plugins/mcollective"
-          ospackage.package_type.should == "Deb"
-        end
-
-        it "should raise an exception if it cannot identify the operating system" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(false)
-          File.expects(:exists?).with("/etc/debian_version").returns(false)
-
-          expect{
-            ospackage = OspackagePackager.new(@testplugin)
-          }.to raise_exception "error: cannot identify operating system."
-        end
-
-        it "should identify if rpmbuild is present for RedHat systems" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(true)
-          File.expects(:exists?).with("./rpmbuild").returns(true)
-          ospackage = OspackagePackager.new(@testplugin)
-        end
-
-        it "should raise an exception if rpmbuild is not present for RedHat systems" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(true)
-          File.expects(:exists?).with("./rpmbuild").returns(false)
-          expect{
-            ospackage = OspackagePackager.new(@testplugin)
-          }.to raise_error "error: package 'rpm-build' is not installed."
-        end
-
-        it "should identify if ar is present for Debian systems" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(false)
-          File.expects(:exists?).with("/etc/debian_version").returns(true)
-          File.expects(:exists?).with("./ar").returns(true)
-
-          ospackage = OspackagePackager.new(@testplugin)
-        end
-
-        it "should raise an exception if the build tool is not present" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(false)
-          File.expects(:exists?).with("/etc/debian_version").returns(true)
-          File.expects(:exists?).with("./ar").returns(false)
-          expect{
-            ospackage = OspackagePackager.new(@testplugin)
-          }.to raise_error "error: package 'ar' is not installed."
-        end
-      end
-
-      describe "#create_packages" do
-        it "should prepare temp directories, create a package and clean up when done" do
-          OspackagePackager.any_instance.stubs(:gem).with("fpm", "= 0.4.3")
-          OspackagePackager.any_instance.stubs(:require).with("fpm")
-          OspackagePackager.any_instance.stubs(:require).with("tmpdir")
-
-          File.expects(:exists?).with("/etc/redhat-release").returns(true)
-          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
-          Dir.expects(:mktmpdir).with("mcollective_packager").returns("/tmp/mcollective_packager")
-          FileUtils.expects(:mkdir_p).with("/tmp/mcollective_packager/usr/libexec/mcollective/mcollective/")
-
-          ospackage = OspackagePackager.new(@testplugin)
-          ospackage.expects(:prepare_tmpdirs).once
-          ospackage.expects(:create_package).once
-          ospackage.expects(:cleanup_tmpdirs).once
-
-          ospackage.create_packages
-        end
+      before :all do
+        @packager = mock()
+        @packager.stubs(:new)
       end
 
-      describe "#create_package" do
-        before :all do
-          module ::FPM
-            class Package
-              class Dir
-              end
-              class RPM
-              end
-            end
-          end
-
-          @fpm_dir = mock
-          @fpm_type = mock
-          @package = mock
-          @fpm_dir.stubs(:convert).returns(@fpm_type)
-          @fpm_dir.stubs(:attributes).returns({:chdir => nil})
-          @fpm_dir.stubs(:input)
-          @package.stubs(:metadata).returns({:name => "testpackage", :version => "1"})
-          @package.stubs(:iteration).returns("1")
-          OspackagePackager.any_instance.stubs(:package).returns(@package)
-        end
-
-        it "should run fpm with the correct parameters" do
-          File.stubs(:exists?).returns(true)
-          OspackagePackager.any_instance.expects(:build_tool?).returns(true)
-          ospackage = OspackagePackager.new(@testpackage)
-          ::FPM::Package::Dir.stubs(:new).returns(@fpm_dir)
-          ospackage.expects(:params)
-          ospackage.expects(:do_quietly?)
-          @fpm_dir.expects(:cleanup)
-          @fpm_type.expects(:cleanup)
-          ospackage.expects(:puts).with("Successfully built RPM 'mcollective-testpackage-testpackage-1-1.noarch.rpm'")
-          ospackage.create_package(:testpackage, {:files => ["/tmp/test.rb"], :description => "testpackage", :dependencies =>"dependencies"})
-        end
+      it "should correctly set members and create the correct packager on redhat" do
+        File.expects(:exists?).with("/etc/redhat-release").returns(true)
+        PluginPackager.expects(:[]).with("RpmpackagePackager").returns(@packager)
+        ospackager = OspackagePackager.new("package")
+        ospackager.package_type.should == "RPM"
       end
 
-      describe "#do_quietly?" do
-        it "should run a block quietly" do
-          require 'stringio'
-
-          File.expects(:exists?).with("/etc/redhat-release").returns(true)
-          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
-          ospackage = OspackagePackager.new(@testplugin)
-
-          old_stdout = $stdout
-          new_stdout = File.open("/tmp/output.txt", "w+")
-          $stdout = new_stdout
-          ospackage.do_quietly?{puts "teststring"}
-          $stdout = old_stdout
-          File.read("/tmp/output.txt").should == ""
-          FileUtils.rm("/tmp/output.txt")
-        end
+      it "should correctly set members and create the correct packager on debian" do
+        File.expects(:exists?).with("/etc/redhat-release").returns(false)
+        File.expects(:exists?).with("/etc/debian_version").returns(true)
+        PluginPackager.expects(:[]).with("DebpackagePackager").returns(@packager)
+        ospackager = OspackagePackager.new("package")
+        ospackager.package_type.should == "Deb"
       end
 
-      describe "#params" do
-        it "should create all paramaters needed by fpm" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(true)
-          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
-          ospackage = OspackagePackager.new(@testplugin)
-
-          fpm_type = mock
-          fpm_type.expects(:name=).with("mcollective-testplugin-testpackage")
-          fpm_type.expects(:maintainer=).with("Psy")
-          fpm_type.expects(:version=).with("0")
-          fpm_type.expects(:url=).with("http://foo.bar.com")
-          fpm_type.expects(:license=).with("Apache 2")
-          fpm_type.expects(:iteration=).with(1)
-          fpm_type.expects(:vendor=).with("Puppet Labs")
-          fpm_type.expects(:architecture=).with("all")
-          fpm_type.expects(:description=).with("A Test Plugin\n\ntestpackage")
-          fpm_type.expects(:dependencies=).with(["mcollective"])
-          fpm_type.expects(:scripts).returns({"post-install" => nil})
-
-          ospackage.params(fpm_type,:testpackage, @testplugin.packagedata[:testpackage])
-
-        end
+      it "should raise an exception if the os can't be identified" do
+        File.expects(:exists?).with("/etc/redhat-release").returns(false)
+        File.expects(:exists?).with("/etc/debian_version").returns(false)
+        expect{
+          OspackagePackager.new("package")
+        }.to raise_error RuntimeError
       end
+    end
 
-      describe "#prepare_tmpdirs" do
-        it "should create temp directories and copy package files" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(true)
-          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
-          File.expects(:directory?).with("/tmp/mcollective_packager/").returns(false)
-          FileUtils.expects(:mkdir_p).with("/tmp/mcollective_packager/")
-          FileUtils.expects(:cp_r).with("/tmp/test.rb", "/tmp/mcollective_packager/")
-
-          ospackage = OspackagePackager.new(@testplugin)
-          ospackage.workingdir = "/tmp/mcollective_packager/"
-          ospackage.prepare_tmpdirs(@testplugin.packagedata[:testpackage])
-        end
+    describe "#create_packages" do
+      before :all do
+        @packager = mock
+        @packager.stubs(:new).returns(@packager)
       end
 
-      describe "#cleanup_tmpdirs" do
-        it "should remove temp directories" do
-          File.expects(:exists?).with("/etc/redhat-release").returns(true)
-          OspackagePackager.any_instance.expects(:build_tool?).with("rpmbuild").returns(true)
-          FileUtils.expects(:rm_r).with("/tmp/mcollective_packager/")
-
-          ospackage = OspackagePackager.new(@testplugin)
-          ospackage.tmpdir = "/tmp/mcollective_packager/"
-          ospackage.cleanup_tmpdirs
-        end
+      it "should call a packagers create_packages class" do
+        File.expects(:exists?).with("/etc/redhat-release").returns(true)
+        PluginPackager.expects(:[]).with("RpmpackagePackager").returns(@packager)
+       @packager.expects(:create_packages)
+        ospackager = OspackagePackager.new("package")
+        ospackager.class.should == OspackagePackager
+        ospackager.create_packages
       end
     end
   end