puppet 2.7.13 → 2.7.14

data/spec/unit/face/module/uninstall_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'puppet/face'
+require 'puppet/module_tool'
+
+describe "puppet module uninstall" do
+  subject { Puppet::Face[:module, :current] }
+
+  let(:options) do
+    {}
+  end
+
+  describe "option validation" do
+    context "without any options" do
+      it "should require a name" do
+        pattern = /wrong number of arguments/
+        expect { subject.uninstall }.to raise_error ArgumentError, pattern
+      end
+
+      it "should not require any options" do
+        Puppet::ModuleTool::Applications::Uninstaller.expects(:run).once
+        subject.uninstall("puppetlabs-apache")
+      end
+    end
+
+    it "should accept the --environment option" do
+      options[:environment] = "development"
+      expected_options = { :environment => 'development' }
+      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", expected_options).once
+      subject.uninstall("puppetlabs-apache", options)
+    end
+
+    it "should accept the --modulepath option" do
+      options[:modulepath] = "/foo/puppet/modules"
+      expected_options = {
+        :modulepath => '/foo/puppet/modules',
+        :environment => 'production',
+      }
+      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", expected_options).once
+      subject.uninstall("puppetlabs-apache", options)
+    end
+
+    it "should accept the --version option" do
+      options[:version] = "1.0.0"
+      expected_options = {
+        :version => '1.0.0',
+        :environment => 'production',
+      }
+      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", expected_options).once
+      subject.uninstall("puppetlabs-apache", options)
+    end
+
+    it "should accept the --force flag" do
+      options[:force] = true
+      expected_options = {
+        :environment => 'production',
+        :force => true,
+      }
+      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", expected_options).once
+      subject.uninstall("puppetlabs-apache", options)
+    end
+  end
+
+  describe "inline documentation" do
+    subject { Puppet::Face[:module, :current].get_action :uninstall }
+
+    its(:summary)     { should =~ /uninstall.*module/im }
+    its(:description) { should =~ /uninstall.*module/im }
+    its(:returns)     { should =~ /hash of module objects.*/im }
+    its(:examples)    { should_not be_empty }
+
+    %w{ license copyright summary description returns examples }.each do |doc|
+      context "of the" do
+        its(doc.to_sym) { should_not =~ /(FIXME|REVISIT|TODO)/ }
+      end
+    end
+  end
+end

data/spec/unit/face/module/upgrade_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'puppet/face'
+require 'puppet/module_tool'
+
+describe "puppet module upgrade" do
+  subject { Puppet::Face[:module, :current] }
+
+  let(:options) do
+    {}
+  end
+
+  describe "inline documentation" do
+    subject { Puppet::Face[:module, :current].get_action :upgrade }
+
+    its(:summary)     { should =~ /upgrade.*module/im }
+    its(:description) { should =~ /upgrade.*module/im }
+    its(:returns)     { should =~ /hash/i }
+    its(:examples)    { should_not be_empty }
+
+    %w{ license copyright summary description returns examples }.each do |doc|
+      context "of the" do
+        its(doc.to_sym) { should_not =~ /(FIXME|REVISIT|TODO)/ }
+      end
+    end
+  end
+end

data/spec/unit/forge/repository_spec.rb

@@ -8,36 +8,6 @@ describe Puppet::Forge::Repository do
 
     let(:repository) { Puppet::Forge::Repository.new('http://fake.com') }
 
-    describe '#make_http_request' do
-      before do
-        # Do a mock of the Proxy call so we can do proper expects for
-        # Net::HTTP
-        Net::HTTP.expects(:Proxy).returns(Net::HTTP)
-        Net::HTTP.expects(:start)
-      end
-      context "when not given an :authenticate option" do
-        it "should authenticate" do
-          repository.expects(:authenticate).never
-          repository.make_http_request(nil)
-        end
-      end
-      context "when given an :authenticate option" do
-        it "should authenticate" do
-          repository.expects(:authenticate)
-          repository.make_http_request(nil, :authenticate => true)
-        end
-      end
-    end
-
-    describe '#authenticate' do
-      it "should set basic auth on the request" do
-        authenticated_request = stub
-        authenticated_request.expects(:basic_auth)
-        repository.expects(:prompt).twice
-        repository.authenticate(authenticated_request)
-      end
-    end
-
     describe '#retrieve' do
       before do
         @uri = URI.parse('http://some.url.com')

data/spec/unit/forge_spec.rb

@@ -1,114 +1,56 @@
 require 'spec_helper'
 require 'puppet/forge'
 require 'net/http'
+require 'puppet/module_tool'
+
+describe Puppet::Forge do
+  include PuppetSpec::Files
+
+  let(:response_body) do
+  <<-EOF
+    [
+      {
+        "author": "puppetlabs",
+        "name": "bacula",
+        "tag_list": ["backup", "bacula"],
+        "releases": [{"version": "0.0.1"}, {"version": "0.0.2"}],
+        "full_name": "puppetlabs/bacula",
+        "version": "0.0.2",
+        "project_url": "http://github.com/puppetlabs/puppetlabs-bacula",
+        "desc": "bacula"
+      }
+    ]
+  EOF
+  end
+  let(:response) { stub(:body => response_body, :code => '200') }
 
-describe Puppet::Forge::Forge do
   before do
     Puppet::Forge::Repository.any_instance.stubs(:make_http_request).returns(response)
     Puppet::Forge::Repository.any_instance.stubs(:retrieve).returns("/tmp/foo")
   end
 
-  let(:forge) { forge = Puppet::Forge::Forge.new('http://forge.puppetlabs.com') }
-
   describe "the behavior of the search method" do
     context "when there are matches for the search term" do
       before do
         Puppet::Forge::Repository.any_instance.stubs(:make_http_request).returns(response)
       end
 
-      let(:response) { stub(:body => response_body, :code => '200') }
-      let(:response_body) do
-      <<-EOF
-        [
-          {
-            "author": "puppetlabs",
-            "name": "bacula",
-            "tag_list": ["backup", "bacula"],
-            "releases": [{"version": "0.0.1"}, {"version": "0.0.2"}],
-            "full_name": "puppetlabs/bacula",
-            "version": "0.0.2",
-            "project_url": "http://github.com/puppetlabs/puppetlabs-bacula",
-            "desc": "bacula"
-          }
-        ]
-      EOF
-      end
-
       it "should return a list of matches from the forge" do
-        forge.search('bacula').should == PSON.load(response_body)
+        Puppet::Forge.search('bacula').should == PSON.load(response_body)
       end
     end
 
     context "when the connection to the forge fails" do
-      let(:response)  { stub(:body => '[]', :code => '404') }
+      let(:response)  { stub(:body => '{}', :code => '404') }
 
-      it "should raise an error" do
-        lambda { forge.search('bacula') }.should raise_error RuntimeError
+      it "should raise an error for search" do
+        lambda { Puppet::Forge.search('bacula') }.should raise_error RuntimeError
       end
-    end
-  end
-
-  describe "the behavior of the get_release_package method" do
 
-    let(:response) do
-      response = mock()
-      response.stubs(:body).returns('{"file": "/system/releases/p/puppetlabs/puppetlabs-apache-0.0.3.tar.gz", "version": "0.0.3"}')
-      response
-    end
-
-    context "when source is not filesystem or repository" do
-      it "should raise an error" do
-        params = { :source => 'foo' }
-        lambda { forge.get_release_package(params) }.should
-          raise_error(ArgumentError, "Could not determine installation source")
-      end
-    end
-
-    context "when the source is a repository" do
-      let(:params) do
-        {
-          :source  => :repository,
-          :author  => 'fakeauthor',
-          :modname => 'fakemodule',
-          :version => '0.0.1'
-        }
-      end
-
-      it "should require author" do
-        params.delete(:author)
-        lambda { forge.get_release_package(params) }.should
-          raise_error(ArgumentError, ":author and :modename required")
-      end
-
-      it "should require modname" do
-        params.delete(:modname)
-        lambda { forge.get_release_package(params) }.should
-          raise_error(ArgumentError, ":author and :modename required")
-      end
-
-      it "should download the release package" do
-        forge.get_release_package(params).should == "/tmp/foo"
-      end
-    end
-
-    context "when the source is a filesystem" do
-      it "should require filename" do
-        params = { :source => :filesystem }
-        lambda { forge.get_release_package(params) }.should
-          raise_error(ArgumentError, ":filename required")
+      it "should raise an error for remote_dependency_info" do
+        lambda { Puppet::Forge.remote_dependency_info('puppetlabs', 'bacula', '0.0.1') }.should raise_error RuntimeError
       end
     end
   end
 
-  describe "the behavior of the get_releases method" do
-    let(:response) do
-      response = mock()
-      response.stubs(:body).returns('{"releases": [{"version": "0.0.1"}, {"version": "0.0.2"}, {"version": "0.0.3"}]}')
-      response
-    end
-
-    it "should return a list of module releases" do
-      forge.get_releases('fakeauthor', 'fakemodule').should == ["0.0.1", "0.0.2", "0.0.3"]
-    end
-  end
 end

data/spec/unit/indirector/catalog/active_record_spec.rb

@@ -1,35 +1,21 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
+describe "Puppet::Resource::Catalog::ActiveRecord", :if => can_use_scratch_database? do
+  include PuppetSpec::Files
 
-describe "Puppet::Resource::Catalog::ActiveRecord", :if => Puppet.features.rails? do
   require 'puppet/rails'
 
-  before :all do
-    class Tableless < ActiveRecord::Base
-      def self.columns
-        @columns ||= []
-      end
-      def self.column(name, sql_type=nil, default=nil, null=true)
-        columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
-      end
-    end
-
-    class Host < Tableless
-      column :name, :string, :null => false
-      column :ip, :string
-      column :environment, :string
-      column :last_compile, :datetime
-    end
+  before :each do
+    require 'puppet/indirector/catalog/active_record'
+    setup_scratch_database
   end
 
-  before do
-    require 'puppet/indirector/catalog/active_record'
-    Puppet.features.stubs(:rails?).returns true
-    Puppet::Rails.stubs(:init)
-    @terminus = Puppet::Resource::Catalog::ActiveRecord.new
+  let :terminus do
+    Puppet::Resource::Catalog::ActiveRecord.new
   end
 
+
   it "should be a subclass of the ActiveRecord terminus class" do
     Puppet::Resource::Catalog::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
   end
@@ -39,35 +25,35 @@ describe "Puppet::Resource::Catalog::ActiveRecord", :if => Puppet.features.rails
   end
 
   describe "when finding an instance" do
-    before do
-      @request = stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
+    let :request do
+      stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
     end
 
     # This hack is here because we don't want to look in the db unless we actually want
     # to look in the db, but our indirection architecture in 0.24.x isn't flexible
     # enough to tune that via configuration.
     it "should return nil unless ':cache_integration_hack' is set to true" do
-      @request.options[:cache_integration_hack] = false
+      request.options[:cache_integration_hack] = false
       Puppet::Rails::Host.expects(:find_by_name).never
-      @terminus.find(@request).should be_nil
+      terminus.find(request).should be_nil
     end
 
     it "should use the Hosts ActiveRecord class to find the host" do
       Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
-      @terminus.find(@request)
+      terminus.find(request)
     end
 
     it "should return nil if no host instance can be found" do
       Puppet::Rails::Host.expects(:find_by_name).returns nil
 
-      @terminus.find(@request).should be_nil
+      terminus.find(request).should be_nil
     end
 
     it "should return a catalog with the same name as the host if the host can be found" do
       host = stub 'host', :name => "foo", :resources => []
       Puppet::Rails::Host.expects(:find_by_name).returns host
 
-      result = @terminus.find(@request)
+      result = terminus.find(request)
       result.should be_instance_of(Puppet::Resource::Catalog)
       result.name.should == "foo"
     end
@@ -87,70 +73,64 @@ describe "Puppet::Resource::Catalog::ActiveRecord", :if => Puppet.features.rails
       catalog.expects(:add_resource).with "trans_res1"
       catalog.expects(:add_resource).with "trans_res2"
 
-      @terminus.find(@request)
+      terminus.find(request)
     end
   end
 
   describe "when saving an instance" do
-    before do
-      @host = Host.new(:name => "foo")
-      @host.stubs(:merge_resources)
-      @host.stubs(:save)
-      @host.stubs(:railsmark).yields
-
-      @node = Puppet::Node.new("foo", :environment => "environment")
-      Puppet::Node.indirection.stubs(:find).with("foo").returns(@node)
-
-      Puppet::Rails::Host.stubs(:find_by_name).returns @host
-      @catalog = Puppet::Resource::Catalog.new("foo")
-      @request = Puppet::Indirector::Request.new(:active_record, :save, @catalog)
+    let :catalog do Puppet::Resource::Catalog.new("foo") end
+    let :request do Puppet::Indirector::Request.new(:active_record, :save, catalog) end
+    let :node do Puppet::Node.new("foo", :environment => "environment") end
+
+    before :each do
+      Puppet::Node.indirection.stubs(:find).with("foo").returns(node)
     end
 
     it "should find the Rails host with the same name" do
-      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
-
-      @terminus.save(@request)
+      Puppet::Rails::Host.expects(:find_by_name).with("foo")
+      terminus.save(request)
     end
 
     it "should create a new Rails host if none can be found" do
-      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
-
-      Puppet::Rails::Host.expects(:create).with(:name => "foo").returns @host
-
-      @terminus.save(@request)
+      Puppet::Rails::Host.find_by_name('foo').should be_nil
+      terminus.save(request)
+      Puppet::Rails::Host.find_by_name('foo').should be_valid
     end
 
     it "should set the catalog vertices as resources on the Rails host instance" do
-      @catalog.expects(:vertices).returns "foo"
-      @host.expects(:merge_resources).with("foo")
+      # We need to stub this so we get the same object, not just the same
+      # content, otherwise the expect can't fire. :(
+      host = Puppet::Rails::Host.create!(:name => "foo")
+      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns(host)
+      catalog.expects(:vertices).returns("foo")
+      host.expects(:merge_resources).with("foo")
 
-      @terminus.save(@request)
+      terminus.save(request)
     end
 
     it "should set host ip if we could find a matching node" do
-      @node.stubs(:parameters).returns({"ipaddress" => "192.168.0.1"})
-
-      @terminus.save(@request)
-      @host.ip.should == '192.168.0.1'
+      node.merge("ipaddress" => "192.168.0.1")
+      terminus.save(request)
+      Puppet::Rails::Host.find_by_name("foo").ip.should == '192.168.0.1'
     end
 
     it "should set host environment if we could find a matching node" do
-      @terminus.save(@request)
-      @host.environment.should == "environment"
+      terminus.save(request)
+      Puppet::Rails::Host.find_by_name("foo").environment.should == "environment"
     end
 
     it "should set the last compile time on the host" do
       now = Time.now
-      Time.expects(:now).returns now
-
-      @terminus.save(@request)
-      @host.last_compile.should == now
+      terminus.save(request)
+      Puppet::Rails::Host.find_by_name("foo").last_compile.should be_within(1).of(now)
     end
 
     it "should save the Rails host instance" do
-      @host.expects(:save)
+      host = Puppet::Rails::Host.create!(:name => "foo")
+      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns(host)
+      host.expects(:save)
 
-      @terminus.save(@request)
+      terminus.save(request)
     end
   end
 end