ml-puppetdb-terminus 3.2.1

data/puppet/spec/unit/reports/puppetdb_spec.rb

@@ -0,0 +1,249 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+require 'puppet/reports'
+require 'net/http'
+require 'puppet/network/http_pool'
+require 'puppet/util/puppetdb/command_names'
+require 'puppet/util/puppetdb/config'
+require 'json'
+
+processor = Puppet::Reports.report(:puppetdb)
+
+describe processor do
+
+  subject {
+    s = Puppet::Transaction::Report.new("foo").extend(processor)
+    s.configuration_version = 123456789
+    s.environment = "foo"
+    s
+  }
+
+  context "#process" do
+
+    let(:http) { mock "http" }
+    let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
+
+    def without_producer_timestamp(json_body)
+      parsed = JSON.parse(json_body)
+      parsed["payload"].delete("producer_timestamp")
+      parsed.to_json
+    end
+
+    it "should POST the report command as a URL-encoded JSON string" do
+      httpok.stubs(:body).returns '{"uuid": "a UUID"}'
+      subject.stubs(:run_duration).returns(10)
+
+      expected_body = {
+        :command => Puppet::Util::Puppetdb::CommandNames::CommandStoreReport,
+        :version => 6,
+        :payload => subject.send(:report_to_hash)
+      }.to_json
+
+      Puppet::Network::HttpPool.expects(:http_instance).returns(http)
+      http.expects(:post).with {|path, body, headers|
+        expect(path).to include(Puppet::Util::Puppetdb::Command::CommandsUrl)
+
+        # producer_timestamp is generated at submission time, so remove it from
+        # the comparison
+        expect(without_producer_timestamp(body)).to eq(without_producer_timestamp(expected_body))
+      }.returns(httpok)
+
+      subject.process
+    end
+  end
+
+  context "#report_to_hash" do
+    let (:resource) {
+      stub("resource",
+        { :pathbuilder => ["foo", "bar", "baz"],
+          :path => "foo",
+          :file => "foo",
+          :line => 1,
+          :tags => [],
+          :title => "foo",
+          :type => "foo" })
+    }
+
+    let (:status) {
+        Puppet::Resource::Status.new(resource)
+    }
+
+    before :each do
+      subject.add_resource_status(status)
+    end
+
+    it "should include the transaction uuid or nil" do
+      subject.transaction_uuid = 'abc123'
+      result = subject.send(:report_to_hash)
+      result["transaction_uuid"].should == 'abc123'
+    end
+
+    context "start/end time" do
+      before :each do
+        subject.add_metric("time", {"total" => 10})
+      end
+
+      it "should base run duration off of the 'time'->'total' metric" do
+        subject.send(:run_duration).should == 10
+      end
+
+      it "should use run_duration to calculate the end_time" do
+        result = subject.send(:report_to_hash)
+        duration = Time.parse(result["end_time"]) - Time.parse(result["start_time"])
+        duration.should == subject.send(:run_duration)
+      end
+    end
+
+    context "events" do
+      before :each do
+        subject.stubs(:run_duration).returns(10)
+      end
+
+      context "resource without events" do
+        it "should not include the resource" do
+          result = subject.send(:report_to_hash)
+          # the server will populate the report id, so we validate that the
+          # client doesn't include one
+          result.has_key?("report").should be_false
+          result["certname"].should == subject.host
+          result["puppet_version"].should == subject.puppet_version
+          result["report_format"].should == subject.report_format
+          result["configuration_version"].should == subject.configuration_version.to_s
+          result["resources"].should == []
+          result["noop"].should == false
+        end
+      end
+
+      context "resource with events" do
+        it "should include the resource" do
+
+          event = Puppet::Transaction::Event.new()
+          event.property = "fooprop"
+          event.desired_value = "fooval"
+          event.previous_value = "oldfooval"
+          event.message = "foomessage"
+          status.add_event(event)
+
+          result = subject.send(:report_to_hash)
+
+          result["resources"].length.should == 1
+          res = result["resources"][0]
+          res["resource_type"].should == "Foo"
+          res["resource_title"].should == "foo"
+          res["file"].should == "foo"
+          res["line"].should == 1
+          res["containment_path"].should == ["foo", "bar", "baz"]
+          res["events"].length.should == 1
+
+          res_event = res["events"][0]
+          res_event["property"].should == "fooprop"
+          res_event["new_value"].should == "fooval"
+          res_event["old_value"].should == "oldfooval"
+          res_event["message"].should == "foomessage"
+        end
+      end
+
+      context "skipped resource status" do
+        it "should include the resource" do
+          status.skipped = true
+          result = subject.send(:report_to_hash)
+
+          result["resources"].length.should == 1
+          resource = result["resources"][0]
+          resource["resource_type"].should == "Foo"
+          resource["resource_title"].should == "foo"
+          resource["containment_path"].should == ["foo", "bar", "baz"]
+          resource["events"].length.should == 0
+        end
+      end
+
+      context "failed resource status" do
+        before :each do
+          status.stubs(:failed).returns(true)
+        end
+
+        context "with no events" do
+          it "should have no events" do
+            result = subject.send(:report_to_hash)
+            result["resources"].length.should == 0
+          end
+        end
+
+        context "with events" do
+          it "should include the actual event" do
+            event = Puppet::Transaction::Event.new
+            event.property = "barprop"
+            event.desired_value = "barval"
+            event.previous_value = "oldbarval"
+            event.message = "barmessage"
+            status.add_event(event)
+
+            result = subject.send(:report_to_hash)
+            result["resources"].length.should == 1
+            resource = result["resources"][0]
+            resource["resource_type"].should == "Foo"
+            resource["resource_title"].should == "foo"
+            resource["file"].should == "foo"
+            resource["line"].should == 1
+            resource["containment_path"].should == ["foo", "bar", "baz"]
+            resource["events"].length.should == 1
+
+            res_event = resource["events"][0]
+            res_event["property"].should == "barprop"
+            res_event["new_value"].should == "barval"
+            res_event["old_value"].should == "oldbarval"
+            res_event["message"].should == "barmessage"
+          end
+        end
+      end
+
+      context "with unchanged resources turned on" do
+        let (:config) {
+          Puppet::Util::Puppetdb.config
+        }
+
+        before :each do
+          config.stubs(:include_unchanged_resources?).returns(true)
+
+          notify_resource =
+            stub("notify_resource",
+                 { :pathbuilder => ["foo", "bar", "baz"],
+                   :path => "foo",
+                   :file => "foo",
+                   :line => "foo",
+                   :tags => [],
+                   :type => "Notify",
+                   :title => "Hello there" })
+          notify_status = Puppet::Resource::Status.new(notify_resource)
+          notify_status.changed = false
+          subject.add_resource_status(notify_status)
+
+          event = Puppet::Transaction::Event.new()
+          event.property = "fooprop"
+          event.desired_value = "fooval"
+          event.previous_value = "oldfooval"
+          event.message = "foomessage"
+          status.add_event(event)
+        end
+
+        context "with an unchanged resource" do
+          it "should include the actual event" do
+            result = subject.send(:report_to_hash)
+            unchanged_resources = result["resources"].select { |res| res["events"].empty? and ! (res["skipped"])}
+            unchanged_resources.length.should == 1
+            resource = unchanged_resources[0]
+            resource["resource_type"].should == "Notify"
+            resource["resource_title"].should == "Hello there"
+            resource["file"].should == "foo"
+            resource["line"].should == "foo"
+            resource["containment_path"].should == ["foo", "bar", "baz"]
+            resource["events"].length.should == 0
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+#!/usr/bin/env rspec
+# encoding: utf-8
+
+require 'spec_helper'
+
+require 'puppet/util/puppetdb/char_encoding'
+
+describe Puppet::Util::Puppetdb::CharEncoding do
+  describe "#ruby_18_clean_utf8", :if => RUBY_VERSION =~ /^1.8/ do
+
+    def test_utf8_clean(in_bytes, expected_bytes)
+      instr = in_bytes.pack('c*')
+      out = described_class.ruby18_clean_utf8(instr)
+      out.should == expected_bytes.pack('c*')
+    end
+
+
+    it "should recognize (and not modify) valid multi-byte characters" do
+      in_bytes = [0xE2, 0x9B, 0x87]
+      expected_bytes = [0xE2, 0x9B, 0x87]
+      test_utf8_clean(in_bytes, expected_bytes)
+    end
+
+    Utf8ReplacementChar = [0xEF, 0xBF, 0xBD]
+    it "should strip invalid UTF-8 characters from an invalid multi-byte sequence" do
+      in_bytes = [0xE2, 0xCB, 0x87]
+      test_utf8_clean(in_bytes, [0xCB, 0x87])
+    end
+
+    it "should strip incomplete multi-byte characters" do
+      in_bytes = [0xE2, 0x9B]
+      test_utf8_clean(in_bytes, [])
+    end
+
+    it "should replace invalid characters with the unicode replacement character" do
+      # This is related to ticket #14873; our utf8_string code for 1.9 is being
+      #  much more aggressive about replacing bytes with the unicode replacement char;
+      #  it appears to be more correct, as the way that the 1.8/IConv approach
+      #  was handling it was causing certain strings to decode differently in
+      #  clojure, thus causing checksum errors.
+      in_bytes = [0x21, 0x7F, 0xFD, 0x80, 0xBD, 0xBB, 0xB6, 0xA1]
+      expected_bytes = [0x21, 0x7F]
+      test_utf8_clean(in_bytes, expected_bytes)
+    end
+
+    # A multi-byte sequence beginning with any of the following bytes is
+    # illegal.  For more info, see http://en.wikipedia.org/wiki/UTF-8
+    [[[0xC0, 0xC1], 2],
+     [[0xF5, 0xF6, 0xF7], 4],
+     [[0xF8, 0xF9, 0xFA, 0xFB], 5],
+     [[0xFC, 0xFD, 0xFE, 0xFF], 6]].each do |bytes, num_bytes|
+      bytes.each do |first_byte|
+        it "should strip the invalid bytes from a #{num_bytes}-byte character starting with 0x#{first_byte.to_s(16)}" do
+          in_bytes = [first_byte]
+          (num_bytes - 1).times { in_bytes << 0x80 }
+          test_utf8_clean(in_bytes, [])
+        end
+      end
+    end
+
+    context "when dealing with multi-byte sequences beginning with 0xF4" do
+      it "should accept characters that are below the 0x10FFFF limit of Unicode" do
+        in_bytes = [0xF4, 0x8f, 0xbf, 0xbf]
+        expected_bytes = [0xF4, 0x8f, 0xbf, 0xbf]
+        test_utf8_clean(in_bytes, expected_bytes)
+      end
+
+      it "should reject characters that are above the 0x10FFFF limit of Unicode" do
+        in_bytes = [0xF4, 0x90, 0xbf, 0xbf]
+        test_utf8_clean(in_bytes, [])
+      end
+    end
+  end
+
+
+  describe "#utf8_string" do
+    describe "on ruby 1.8", :if => RUBY_VERSION =~ /^1.8/ do
+      it "should convert from ascii without a warning" do
+        Puppet.expects(:warning).never
+
+        str = "any ascii string"
+        subject.utf8_string(str, nil).should == str
+      end
+
+      it "should strip invalid chars from non-overlapping latin-1 with a warning" do
+        Puppet.expects(:warning).with {|msg| msg =~ /Ignoring invalid UTF-8 byte sequences/}
+
+        str = "a latin-1 string \xd6"
+        subject.utf8_string(str, nil).should == "a latin-1 string "
+      end
+
+      it "should strip invalid chars and warn if the string is invalid UTF-8" do
+        Puppet.expects(:warning).with {|msg| msg =~ /Ignoring invalid UTF-8 byte sequences/}
+
+        str = "an invalid utf-8 string \xff"
+        subject.utf8_string(str, nil).should == "an invalid utf-8 string "
+      end
+
+      it "should return a valid utf-8 string without warning" do
+        Puppet.expects(:warning).never
+
+        str = "a valid utf-8 string \xc3\x96"
+        subject.utf8_string(str, nil).should == str
+      end
+    end
+
+    describe "on ruby > 1.8", :if => RUBY_VERSION !~ /^1.8/ do
+      it "should convert from ascii without a warning" do
+        Puppet.expects(:warning).never
+
+        str = "any ascii string".force_encoding('us-ascii')
+        subject.utf8_string(str, nil).should == str
+      end
+
+      it "should convert from latin-1 without a warning" do
+        Puppet.expects(:warning).never
+
+        str = "a latin-1 string Ö".force_encoding('ASCII-8BIT')
+        subject.utf8_string(str, nil).should == "a latin-1 string Ö"
+      end
+
+      # UndefinedConversionError
+      it "should replace undefined characters and warn when converting from binary" do
+        Puppet.expects(:warning).with {|msg| msg =~ /Error with command ignoring invalid UTF-8 byte sequences/}
+
+        str = "an invalid binary string \xff".force_encoding('binary')
+        # \ufffd == unicode replacement character
+        subject.utf8_string(str, "Error with command").should == "an invalid binary string \ufffd"
+      end
+
+      # InvalidByteSequenceError
+      it "should replace undefined characters and warn if the string is invalid UTF-8" do
+        Puppet.expects(:warning).with {|msg| msg =~ /Error with command ignoring invalid UTF-8 byte sequences/}
+
+        str = "an invalid utf-8 string \xff".force_encoding('utf-8')
+        subject.utf8_string(str, "Error with command").should == "an invalid utf-8 string \ufffd"
+      end
+
+      it "should leave the string alone if it's valid UTF-8" do
+        Puppet.expects(:warning).never
+
+        str = "a valid utf-8 string".force_encoding('utf-8')
+        subject.utf8_string(str, nil).should == str
+      end
+
+      it "should leave the string alone if it's valid UTF-8 with non-ascii characters" do
+        Puppet.expects(:warning).never
+
+        str = "a valid utf-8 string Ö"
+        subject.utf8_string(str.dup.force_encoding('ASCII-8BIT'), nil).should == str
+      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 emit a warning and debug messages when bad characters are found" do
+          Puppet[:log_level] = "debug"
+          Puppet.expects(:warning).with {|msg| msg =~ /Error encoding a 'replace facts' command for host 'foo.com' ignoring invalid/}
+          Puppet.expects(:debug).with do |msg|
+            msg =~ /Error encoding a 'replace facts' command for host 'foo.com'/ &&
+            msg =~ /'some valid string' followed by 1 invalid\/undefined bytes then ''/
+          end
+
+          # This will create a UTF-8 string literal, then switch to ASCII-8Bit when the bad
+          # bytes are concated on below
+          str = "some valid string" << [192].pack('c*')
+          subject.utf8_string(str, "Error encoding a 'replace facts' command for host 'foo.com'").should == "some valid string\ufffd"
+        end
+      end
+
+      it "should emit a warning and no debug messages" do
+        Puppet.expects(:warning).with {|msg| msg =~ /Error on replace catalog ignoring invalid UTF-8 byte sequences/}
+        Puppet.expects(:debug).never
+        str = "some valid string" << [192].pack('c*')
+        subject.utf8_string(str, "Error on replace catalog").should == "some valid string\ufffd"
+      end
+    end
+  end
+
+  describe "on ruby > 1.8", :if => RUBY_VERSION !~ /^1.8/ do
+    it "finds all index of a given character" do
+      described_class.all_indexes_of_char("a\u2192b\u2192c\u2192d\u2192", "\u2192").should == [1, 3, 5, 7]
+      described_class.all_indexes_of_char("abcd", "\u2192").should == []
+    end
+
+    it "should collapse consecutive integers into ranges" do
+      described_class.collapse_ranges((1..5).to_a).should == [1..5]
+      described_class.collapse_ranges([]).should == []
+      described_class.collapse_ranges([1,2,3,5,7,8,9]).should == [1..3, 5..5, 7..9]
+    end
+
+    it "gives error context around each bad character" do
+      described_class.error_char_context("abc\ufffddef", [3]).should ==
+        ["'abc' followed by 1 invalid/undefined bytes then 'def'"]
+
+      described_class.error_char_context("abc\ufffd\ufffd\ufffd\ufffddef", [3,4,5,6]).should ==
+        ["'abc' followed by 4 invalid/undefined bytes then 'def'"]
+
+      described_class.error_char_context("abc\ufffddef\ufffdg", [3, 7]).should ==
+        ["'abc' followed by 1 invalid/undefined bytes then 'def'",
+         "'def' followed by 1 invalid/undefined bytes then 'g'"]
+    end
+  end
+end