ml-puppetdb-terminus 3.2.1

data/puppet/spec/unit/util/puppetdb/command_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'digest/sha1'
+require 'puppet/network/http_pool'
+require 'puppet/util/puppetdb'
+
+
+describe Puppet::Util::Puppetdb::Command do
+  let(:payload) { {'resistance' =>  'futile', 'opinion' => 'irrelevant'} }
+  let(:subject) { described_class.new("OPEN SESAME", 1,
+                                      'foo.localdomain', payload) }
+
+
+  describe "#submit" do
+    let(:http) { mock 'http' }
+    before(:each) do
+      Puppet::Network::HttpPool.expects(:http_instance).returns http
+    end
+
+    context "when the submission succeeds" do
+      let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
+
+      it "should issue the HTTP POST and log success" do
+        httpok.stubs(:body).returns '{"uuid": "a UUID"}'
+        http.expects(:post).returns httpok
+
+        subject.submit
+        test_logs.find_all { |m|
+          m =~ /'#{subject.command}' command for #{subject.certname} submitted to PuppetDB/
+        }.length.should == 1
+      end
+    end
+
+    context "when the submission fails" do
+      let(:httpbad) { Net::HTTPBadRequest.new('1.1', 400, '') }
+
+      it "should issue the HTTP POST and raise an exception" do
+
+        httpbad.stubs(:body).returns 'Strange things are afoot'
+        http.expects(:post).returns httpbad
+        expect {
+          subject.submit
+        }.to raise_error(Puppet::Error, /Strange things are afoot/)
+      end
+
+      it 'when soft_write_failure is enabled should just invoke Puppet.err' do
+        subject.expects(:config).at_least_once.returns \
+          OpenStruct.new({:soft_write_failure => true})
+
+        httpbad.stubs(:body).returns 'Strange things are afoot'
+        http.expects(:post).returns httpbad
+        Puppet.expects(:err).with do |msg|
+          msg =~ /Strange things are afoot/
+        end
+        subject.submit
+      end
+    end
+  end
+
+  it "should not warn when the the string contains valid UTF-8 characters" do
+    Puppet.expects(:warning).never
+    cmd = described_class.new("command-1", 1, "foo.localdomain", {"foo" => "\u2192"})
+    cmd.payload.include?("\u2192").should be_true
+  end
+
+  describe "on ruby > 1.8", :if => RUBY_VERSION !~ /^1.8/ do
+
+    it "should warn when a command payload includes non-ascii UTF-8 characters" do
+      Puppet.expects(:warning).with {|msg| msg =~ /Error encoding a 'command-1' command for host 'foo.localdomain' ignoring invalid UTF-8 byte sequences/}
+      cmd = described_class.new("command-1", 1, "foo.localdomain", {"foo" => [192].pack('c*')})
+      cmd.payload.include?("\ufffd").should be_true
+    end
+
+    describe "Debug log testing of bad data" do
+      let!(:existing_log_level){ Puppet[:log_level]}
+
+      before :each do
+        Puppet[:log_level] = "debug"
+      end
+
+      after :each do
+        Puppet[:log_level] = "notice"
+      end
+
+      it "should warn when a command payload includes non-ascii UTF-8 characters" do
+        Puppet.expects(:warning).with do |msg|
+          msg =~ /Error encoding a 'command-1' command for host 'foo.localdomain' ignoring invalid UTF-8 byte sequences/
+        end
+        Puppet.expects(:debug).with do |msg|
+          msg =~ /Error encoding a 'command-1' command for host 'foo.localdomain'/ &&
+            msg =~ Regexp.new(Regexp.quote('"command":"command-1","version":1,"payload":{"foo"')) &&
+            msg =~ /1 invalid\/undefined/
+        end
+        cmd = described_class.new("command-1", 1, "foo.localdomain", {"foo" => [192].pack('c*')})
+        cmd.payload.include?("\ufffd").should be_true
+      end
+    end
+  end
+end

data/puppet/spec/unit/util/puppetdb/config_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+require 'puppet/util/puppetdb/config'
+require 'puppet/util/puppetdb/command_names'
+
+# Create a local copy of these constants so that we don't have to refer to them
+# by their full namespaced name
+CommandReplaceCatalog   = Puppet::Util::Puppetdb::CommandNames::CommandReplaceCatalog
+CommandReplaceFacts     = Puppet::Util::Puppetdb::CommandNames::CommandReplaceFacts
+CommandStoreReport      = Puppet::Util::Puppetdb::CommandNames::CommandStoreReport
+
+describe Puppet::Util::Puppetdb::Config do
+  describe "#load" do
+    let(:confdir) do
+      temp = Tempfile.new('confdir')
+      path = temp.path
+      temp.close!
+      Dir.mkdir(path)
+      path
+    end
+
+    before :each do
+      Puppet[:confdir] = confdir
+    end
+
+    after :each do
+      FileUtils.rm_rf(confdir)
+    end
+
+    describe "with no config file" do
+      it "should use the default settings" do
+        config = described_class.load
+        config.server_urls.should == [URI("https://puppetdb:8081")]
+      end
+
+    end
+
+    describe "with a config file" do
+      def write_config(content)
+        conf = File.join(confdir, 'puppetdb.conf')
+        File.open(conf, 'w') { |file| file.print(content) }
+      end
+
+      it "should not explode if there are comments in the config file" do
+        write_config <<CONF
+#this is a comment
+ ; so is this
+[main]
+server = main-server
+   # yet another comment
+port = 1234
+CONF
+        expect { described_class.load }.to_not raise_error
+      end
+
+
+      it "should use the config value if specified" do
+        write_config <<CONF
+[main]
+server = main-server
+port = 1234
+soft_write_failure = true
+CONF
+        config = described_class.load
+        config.server_urls.should == [URI("https://main-server:1234")]
+        config.soft_write_failure.should be_true
+      end
+
+      it "should use the default if no value is specified" do
+        write_config ''
+
+        config = described_class.load
+        config.server_urls.should == [URI("https://puppetdb:8081")]
+        config.soft_write_failure.should be_false
+      end
+
+      it "should be insensitive to whitespace" do
+        write_config <<CONF
+[main]
+  server = main-server
+    port    =  1234
+CONF
+        config = described_class.load
+        config.server_urls.should == [URI("https://main-server:1234")]
+      end
+
+      it "should accept valid hostnames" do
+        write_config <<CONF
+[main]
+server = foo.example-thing.com
+port = 8081
+CONF
+
+        config = described_class.load
+        config.server_urls.should == [URI("https://foo.example-thing.com:8081")]
+      end
+
+      it "should raise if a setting is outside of a section" do
+        write_config 'foo = bar'
+
+        expect do
+          described_class.load
+        end.to raise_error(/Setting 'foo = bar' is illegal outside of section/)
+      end
+
+      it "should raise if an illegal line is encountered" do
+        write_config 'foo bar baz'
+
+        expect do
+          described_class.load
+        end.to raise_error(/Unparseable line 'foo bar baz'/)
+      end
+
+      it "should accept a single url" do
+        write_config <<CONF
+[main]
+server_urls = https://foo.something-different.com:8080
+CONF
+
+        config = described_class.load
+        config.server_urls.should == [URI("https://foo.something-different.com:8080")]
+      end
+
+      it "should accept multiple urls" do
+        write_config <<CONF
+[main]
+server = foo.example-thing.com
+port = 8081
+server_urls = https://foo.something-different.com,https://bar.example-thing.com:8989
+CONF
+
+        config = described_class.load
+        config.server_urls.should == [URI("https://foo.something-different.com"), URI("https://bar.example-thing.com:8989")]
+      end
+
+      it "should fail if given an http URL" do
+        write_config <<CONF
+[main]
+server_urls = http://foo.something-different.com
+CONF
+
+        expect do
+          config = described_class.load
+        end.to raise_error(/PuppetDB 'server_urls' must be https, found 'http:\/\/foo.something-different.com'/)
+      end
+      
+      it "should fail if given a URL path" do
+        uri_string = ""
+        write_config <<CONF
+[main]
+server_urls = https://foo.something-different.com/bar
+CONF
+
+        expect do
+          config = described_class.load
+        end.to raise_error(/PuppetDB 'server_urls' cannot contain URL paths, found 'https:\/\/foo.something-different.com\/bar'/)
+      end
+
+      it "should fail if given a server/port combo" do
+        write_config <<CONF
+[main]
+server_urls = foo.com:8080
+CONF
+
+        expect do
+          config = described_class.load
+        end.to raise_error(/PuppetDB 'server_urls' must be https, found 'foo.com:8080'/)
+      end
+
+      it "should fail if given a server only" do
+        write_config <<CONF
+[main]
+server_urls = foo.com
+CONF
+
+        expect do
+          config = described_class.load
+        end.to raise_error(/PuppetDB 'server_urls' must be https, found 'foo.com'/)
+      end
+
+
+      it "should fail if given an invalid hostname" do
+        write_config <<CONF
+[main]
+server_urls = https://invalid_host_name.com
+CONF
+
+        expect do
+          config = described_class.load
+        end.to raise_error(/Error parsing URL 'https:\/\/invalid_host_name.com' in PuppetDB 'server_urls'/)
+      end
+
+      it "should fail if given an unparsable second URI" do
+        write_config <<CONF
+[main]
+server_urls = https://foo.com,https://invalid_host_name.com
+CONF
+
+        expect do
+          config = described_class.load
+        end.to raise_error(/Error parsing URL 'https:\/\/invalid_host_name.com' in PuppetDB 'server_urls'/)
+      end
+
+      it "should fail if given an unparsable second URI" do
+        write_config <<CONF
+[main]
+server_urls = https://foo.com,https://invalid_host_name.com
+CONF
+
+        expect do
+          config = described_class.load
+        end.to raise_error(/Error parsing URL 'https:\/\/invalid_host_name.com' in PuppetDB 'server_urls'/)
+      end
+
+      it "should tolerate spaces between URLs" do
+        write_config <<CONF
+[main]
+server_urls = https://foo.something-different.com   ,      https://bar.example-thing.com:8989,    https://baz.example-thing.com:8989
+CONF
+
+        config = described_class.load
+        config.server_urls.should == [URI("https://foo.something-different.com"),
+                                      URI("https://bar.example-thing.com:8989"),
+                                      URI("https://baz.example-thing.com:8989")]
+      end
+    end
+  end
+end

data/puppet/spec/unit/util/puppetdb/http_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'puppet/util/puppetdb/http'
+
+describe Puppet::Util::Puppetdb::Http do
+
+  describe "#concat_url_snippets" do
+    it "should avoid a double slash" do
+      described_class.concat_url_snippets('/foo/', '/bar/').should == '/foo/bar/'
+    end
+    it "should add a slash if needed" do
+      described_class.concat_url_snippets('/foo', 'bar/').should == '/foo/bar/'
+      described_class.concat_url_snippets('/foo', 'bar/').should == '/foo/bar/'
+    end
+    it "should do the right thing if only one snippet has a slash" do
+      described_class.concat_url_snippets('/foo', '/bar/').should == '/foo/bar/'
+      described_class.concat_url_snippets('/foo/', 'bar/').should == '/foo/bar/'
+    end
+  end
+
+  before :each do
+      Puppet::Util::Puppetdb.stubs(:config).returns config
+  end
+
+  let(:config) do
+    config = stub 'config'
+    config.stubs(:server_urls).returns [URI("https://server1:8080/foo"), URI("https://server2:8181/bar")]
+    config.stubs(:server_url_timeout).returns 30
+    config.stubs(:server_url_config?).returns false
+    config
+  end
+  let(:http1) {stub 'http'}
+  let(:http2) {stub 'http'}
+
+
+  describe "#action" do
+    it "call the proc argument with a correct path" do
+
+      Puppet::Network::HttpPool.expects(:http_instance).returns(http1)
+      http1.expects(:get).with("/foo/bar/baz", {}).returns Net::HTTPOK.new('1.1', 200, 'OK')
+
+      described_class.action("/bar/baz") do |http_instance, path|
+        http_instance.get(path, {})
+      end
+    end
+
+    it "should not fail over when the first url works" do
+      Puppet::Network::HttpPool.expects(:http_instance).with("server1", 8080).returns(http1)
+      Puppet::Network::HttpPool.expects(:http_instance).with("server2", 8181).never
+
+      http1.expects(:get).with("/foo/baz", {}).returns Net::HTTPOK.new('1.1', 200, 'OK')
+
+      response = described_class.action("/baz") do |http_instance, path|
+        http_instance.get(path, {})
+      end
+
+      response.code.should == 200
+      response.message.should == 'OK'
+
+    end
+
+
+    it "fails over to the next url when it can't connect" do
+      Puppet::Network::HttpPool.expects(:http_instance).with("server1", 8080).returns(http1)
+      Puppet::Network::HttpPool.expects(:http_instance).with("server2", 8181).returns(http2)
+
+      http1.expects(:get).with("/foo/baz", {}).raises SystemCallError, "Connection refused"
+      http2.expects(:get).with("/bar/baz", {}).returns Net::HTTPOK.new('1.1', 200, 'OK')
+
+      response = described_class.action("/baz") do |http_instance, path|
+        http_instance.get(path, {})
+      end
+
+      response.code.should == 200
+      response.message.should == 'OK'
+
+    end
+
+    it "fails over to the next url on a server error" do
+      Puppet::Network::HttpPool.expects(:http_instance).with("server1", 8080).returns(http1)
+      Puppet::Network::HttpPool.expects(:http_instance).with("server2", 8181).returns(http2)
+
+      http1.expects(:get).with("/foo/baz", {}).returns Net::HTTPServiceUnavailable.new('1.1', 503, "Unavailable")
+      http2.expects(:get).with("/bar/baz", {}).returns Net::HTTPOK.new('1.1', 200, 'OK')
+
+      response = described_class.action("/baz") do |http_instance, path|
+        http_instance.get(path, {})
+      end
+
+      response.code.should == 200
+      response.message.should == 'OK'
+    end
+
+    it "raises an exception when all urls fail" do
+      Puppet::Network::HttpPool.expects(:http_instance).with("server1", 8080).returns(http1)
+      Puppet::Network::HttpPool.expects(:http_instance).with("server2", 8181).returns(http2)
+
+      http1.expects(:get).with("/foo/baz", {}).returns Net::HTTPServiceUnavailable.new('1.1', 503, "Unavailable")
+      http2.expects(:get).with("/bar/baz", {}).returns Net::HTTPServiceUnavailable.new('1.1', 503, "Unavailable")
+
+
+      expect {
+         described_class.action("/baz") do |http_instance, path|
+           http_instance.get(path, {})
+         end
+      }.to raise_error Puppet::Error, /Failed to execute/
+    end
+
+    it "fails over after IOError" do
+      Puppet::Network::HttpPool.expects(:http_instance).with("server1", 8080).returns(http1)
+      Puppet::Network::HttpPool.expects(:http_instance).with("server2", 8181).returns(http2)
+
+      http1.expects(:get).with("/foo/baz", {}).raises IOError
+      http2.expects(:get).with("/bar/baz", {}).returns Net::HTTPOK.new('1.1', 200, 'OK')
+
+      response = described_class.action("/baz") do |http_instance, path|
+        http_instance.get(path, {})
+      end
+
+      response.code.should == 200
+      response.message.should == 'OK'
+    end
+
+    it "times out and rolls to the next url" do
+      Puppet::Network::HttpPool.expects(:http_instance).with("server1", 8080).returns(http1)
+      Puppet::Network::HttpPool.expects(:http_instance).with("server2", 8181).returns(http2)
+
+      http1.expects(:get).with("/foo/baz", {}).raises Timeout::Error
+      http2.expects(:get).with("/bar/baz", {}).returns Net::HTTPOK.new('1.1', 200, 'OK')
+
+      response = described_class.action("/baz") do |http_instance, path|
+        http_instance.get(path, {})
+      end
+
+      response.code.should == 200
+      response.message.should == 'OK'
+    end
+  end
+end