ml-puppetdb-terminus 3.2.1

data/puppet/spec/unit/indirector/facts/puppetdb_apply_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'puppet/indirector/facts/puppetdb_apply'
+
+describe Puppet::Node::Facts::PuppetdbApply do
+  describe "#save" do
+    let(:facts)    { Puppet::Node::Facts.new('foo') }
+
+    def save
+      subject.save(Puppet::Node::Facts.indirection.request(:save, facts.name, facts))
+    end
+
+    it "should only submit commands once" do
+      subject.expects(:submit_command).once
+      save
+      save
+      save
+    end
+
+  end
+
+  describe "#find" do
+    it "always returns nil to force the cache to be skipped" do
+      subject.find('foo').should be_nil
+    end
+  end
+
+end

data/puppet/spec/unit/indirector/facts/puppetdb_spec.rb

@@ -0,0 +1,347 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/feature'
+require 'puppet/indirector/facts/puppetdb'
+require 'puppet/util/puppetdb'
+require 'puppet/util/puppetdb/command_names'
+require 'json'
+
+
+describe Puppet::Node::Facts::Puppetdb do
+
+  CommandReplaceFacts = Puppet::Util::Puppetdb::CommandNames::CommandReplaceFacts
+
+  let(:http) {stub 'http'}
+
+  before :each do
+    Puppet::Util::Puppetdb.config.stubs(:server_urls).returns [URI("https://localhost:8282")]
+    Puppet::Node::Facts.indirection.stubs(:terminus).returns(subject)
+    Puppet::Network::HttpPool.stubs(:http_instance).returns(http)
+    create_environmentdir("my_environment")
+  end
+
+  describe "#save" do
+    let(:response) { Net::HTTPOK.new('1.1', 200, 'OK') }
+    let(:facts)    { Puppet::Node::Facts.new('foo') }
+
+    let(:options) {{
+      :producer_timestamp => 'a test',
+      :environment => "my_environment",
+    }}
+
+    before :each do
+      response.stubs(:body).returns '{"uuid": "a UUID"}'
+    end
+
+    def save
+      subject.save(Puppet::Node::Facts.indirection.request(:save, facts.name, facts, options))
+    end
+
+    it "should POST the facts as a JSON string" do
+      Puppet::Util::Puppetdb.stubs(:puppet3compat?).returns(true)
+      f = {
+        "certname" => facts.name,
+        "values" => subject.maybe_strip_internal(facts),
+        "environment" => "my_environment",
+        "producer_timestamp" => "a test",
+      }
+
+      payload = {
+        :command => CommandReplaceFacts,
+        :version => 4,
+        :payload => f,
+      }.to_json
+
+      http.expects(:post).with do |uri, body, headers|
+        expect(body).to eq(payload)
+      end.returns response
+
+      save
+    end
+
+    it "should POST the trusted data we tell it to" do
+
+      if Puppet::Util::Puppetdb.puppet3compat?
+        Puppet[:trusted_node_data] = true
+      end
+
+      trusted_data = {"foo" => "foobar", "certname" => "testing_posting"}
+      subject.stubs(:get_trusted_info).returns trusted_data
+
+      f = {
+        "certname" => facts.name,
+        "values" => subject.maybe_strip_internal(facts).merge({"trusted" => trusted_data}),
+        "environment" => "my_environment",
+        "producer_timestamp" => "a test",
+      }
+
+      payload = {
+        :command => CommandReplaceFacts,
+        :version => 4,
+        :payload => f,
+      }.to_pson
+
+      http.expects(:post).with do |uri, body, headers|
+        expect(body).to eq(payload)
+      end.returns response
+
+      save
+    end
+
+
+    it "should retain integer type when submitting" do
+      facts.values['something'] = 100
+
+      sent_payload = nil
+      http.expects(:post).with do |uri, body, headers|
+        sent_payload = body
+      end.returns response
+
+      save
+
+      message = JSON.parse(sent_payload)
+      sent_facts = message['payload']
+
+      # We shouldn't modify the original instance
+      facts.values['something'].should == 100
+      sent_facts['values']['something'].should == 100
+    end
+  end
+
+  describe "#get_trusted_info" do
+    it 'should return trusted data' do
+      node = Puppet::Node.new('my_certname')
+      trusted = subject.get_trusted_info(node)
+      # Extra keys domain & hostname introduced by PUP-5097, Puppet 4.3.0
+      if trusted.has_key?("domain")
+        expect(trusted).to eq({'authenticated'=>'local', 'certname'=>'testing',
+                               'extensions'=>{}, 'hostname'=>'testing', 'domain'=>nil})
+      else
+        # Puppet 4.2.x and older
+        expect(trusted).to eq({'authenticated'=>'local', 'certname'=>'testing', 'extensions'=>{}})
+      end
+    end
+
+    it 'should return trusted data when falling back to the node' do
+      # This removes :trusted_information from the global context, triggering our fallback code.
+      if Puppet.methods.include? :rollback_context
+        Puppet.rollback_context('initial testing state')
+      else
+        Puppet.pop_context # puppet 3.5.1
+      end
+
+      node = Puppet::Node.new('my_certname', :parameters => {'clientcert' => 'trusted_certname'})
+      trusted = subject.get_trusted_info(node)
+
+      # Extra keys domainname & hostname introduced by PUP-5097, Puppet 4.3.0
+      if trusted.has_key?("domain")
+        expect(trusted).to eq({'authenticated'=>'local', 'certname'=>'trusted_certname',
+                               'extensions'=>{}, 'hostname'=>'trusted_certname', 'domain'=>nil})
+      else
+        # Puppet 4.2.x and older
+        expect(trusted).to eq({'authenticated'=>'local', 'certname'=>'trusted_certname', 'extensions'=>{}})
+      end
+
+      # Put the context back the way the test harness expects
+      Puppet.push_context({}, 'context to make the tests happy')
+      if Puppet.methods.include? :mark_context
+        Puppet.mark_context('initial testing state')
+      end
+    end
+  end
+
+  describe "#find" do
+    def find_facts()
+      Puppet::Node::Facts.indirection.find('some_node')
+    end
+
+    it "should return the facts if they're found" do
+      body = [{"certname" => "some_node", "environment" => "production", "name" => "a", "value" => "1"},
+              {"certname" => "some_node", "environment" => "production", "name" => "b", "value" => "2"}].to_json
+
+      response = Net::HTTPOK.new('1.1', 200, 'OK')
+      response.stubs(:body).returns body
+
+      http.stubs(:get).with("/pdb/query/v4/nodes/some_node/facts", subject.headers).returns response
+
+      result = find_facts
+      result.should be_a(Puppet::Node::Facts)
+      result.name.should == 'some_node'
+      result.values.should include('a' => '1', 'b' => '2')
+    end
+
+    it "should return nil if no facts are found" do
+      body = {"error" => "No information known about factset some_node"}.to_json
+
+      response = Net::HTTPNotFound.new('1.1', 404, 'NotFound')
+      response.stubs(:body).returns body
+
+      http.stubs(:get).with("/pdb/query/v4/nodes/some_node/facts", subject.headers).returns response
+
+      find_facts.should be_nil
+    end
+
+    it "should fail if an HTTP error code is returned" do
+      response = Net::HTTPForbidden.new('1.1', 403, "Forbidden")
+      response.stubs(:body).returns ''
+
+      http.stubs(:get).with("/pdb/query/v4/nodes/some_node/facts", subject.headers).returns response
+
+      expect {
+        find_facts
+      }.to raise_error Puppet::Error, /\[403 Forbidden\]/
+    end
+
+    it "should fail if an error occurs" do
+      http.stubs(:get).with("/pdb/query/v4/nodes/some_node/facts", subject.headers).raises Puppet::Error, "Everything is terrible!"
+
+      expect {
+        find_facts
+      }.to raise_error Puppet::Error, /Everything is terrible!/
+    end
+
+    it "should log a deprecation warning if one is returned from PuppetDB" do
+      response = Net::HTTPOK.new('1.1', 200, 'OK')
+      response['x-deprecation'] = "This is deprecated!"
+
+      body = [].to_json
+
+      response.stubs(:body).returns body
+
+      http.stubs(:get).with("/pdb/query/v4/nodes/some_node/facts", subject.headers).returns(response)
+
+      Puppet.expects(:deprecation_warning).with do |msg|
+        msg =~ /This is deprecated!/
+      end
+
+      find_facts
+    end
+  end
+
+  describe "#search" do
+    def search_facts(query)
+      Puppet::Node::Facts.indirection.search('facts', query)
+    end
+    let(:response) { Net::HTTPOK.new('1.1', 200, 'OK') }
+
+    it "should return the nodes from the response" do
+      args = {
+        'facts.kernel.eq' => 'Linux',
+      }
+
+      response.stubs(:body).returns '["foo", "bar", "baz"]'
+      response.stubs(:body).returns '[{"name": "foo", "deactivated": null, "expired": null, "catalog_timestamp": null, "facts_timestamp": null, "report_timestamp": null},
+                                      {"name": "bar", "deactivated": null, "expired": null, "catalog_timestamp": null, "facts_timestamp": null, "report_timestamp": null},
+                                      {"name": "baz", "deactivated": null, "expired": null, "catalog_timestamp": null, "facts_timestamp": null, "report_timestamp": null}]'
+
+      query = CGI.escape("[\"and\",[\"=\",[\"fact\",\"kernel\"],\"Linux\"]]")
+      http.stubs(:get).with("/pdb/query/v4/nodes?query=#{query}",  subject.headers).returns(response)
+
+      search_facts(args).should == ['foo', 'bar', 'baz']
+    end
+
+    it "should only allow searches against facts" do
+      args = {
+        'facts.kernel.eq' => 'Linux',
+        'wrong.kernel.eq' => 'Linux',
+      }
+
+      expect do
+        search_facts(args)
+      end.to raise_error(Puppet::Error, /Fact search against keys of type 'wrong' is unsupported/)
+    end
+
+    it "should combine multiple terms with 'and'" do
+      args = {
+        'facts.kernel.eq' => 'Linux',
+        'facts.uptime.eq' => '10 days',
+      }
+
+      query = CGI.escape(["and", ["=", ["fact", "kernel"], "Linux"],
+                                 ["=", ["fact", "uptime"], "10 days"]].to_json)
+
+      response.stubs(:body).returns '[]'
+
+      http.stubs(:get).with("/pdb/query/v4/nodes?query=#{query}",  subject.headers).returns(response)
+
+      search_facts(args)
+    end
+
+    it "should add 'not' to a != query" do
+      args = {
+        'facts.kernel.ne' => 'Linux',
+      }
+
+      query = CGI.escape(["and", ["not", ["=", ["fact", "kernel"], "Linux"]]].to_json)
+
+      response.stubs(:body).returns '[]'
+
+      http.stubs(:get).with("/pdb/query/v4/nodes?query=#{query}",  subject.headers).returns(response)
+
+      search_facts(args)
+    end
+
+    it "should default the operator to = if one is not specified" do
+      args = {
+        'facts.kernel' => 'Linux',
+      }
+
+      query = CGI.escape(["and", ["=", ["fact", "kernel"], "Linux"]].to_json)
+
+      response.stubs(:body).returns '[]'
+
+      http.stubs(:get).with("/pdb/query/v4/nodes?query=#{query}",  subject.headers).returns(response)
+
+      search_facts(args)
+    end
+
+    {
+      'gt' => '>',
+      'lt' => '<',
+      'ge' => '>=',
+      'le' => '<='
+    }.each do |name, operator|
+      it "should map '#{name}' to #{operator}" do
+        args = {
+          "facts.kernel.#{name}" => 'Linux',
+        }
+
+        query = CGI.escape(["and", [operator, ["fact", "kernel"], "Linux"]].to_json)
+
+        response.stubs(:body).returns '[]'
+
+        http.stubs(:get).with("/pdb/query/v4/nodes?query=#{query}",  subject.headers).returns(response)
+
+        search_facts(args)
+      end
+    end
+
+    it "should raise an error if a failure occurs" do
+      response = Net::HTTPBadRequest.new('1.1', 400, 'Bad Request')
+      response.stubs(:body).returns 'Something bad happened!'
+
+      query = CGI.escape(["and"].to_json)
+      http.stubs(:get).with("/pdb/query/v4/nodes?query=#{query}",  subject.headers).returns(response)
+
+      expect do
+        search_facts(nil)
+      end.to raise_error(Puppet::Error, /\[400 Bad Request\] Something bad happened!/)
+
+    end
+
+    it "should log a deprecation warning if one is returned from PuppetDB" do
+      response['x-deprecation'] = "This is deprecated!"
+      response.stubs(:body).returns '[]'
+
+      query = CGI.escape(["and"].to_json)
+      http.stubs(:get).with("/pdb/query/v4/nodes?query=#{query}",  subject.headers).returns(response)
+
+      Puppet.expects(:deprecation_warning).with do |msg|
+        msg =~ /This is deprecated!/
+      end
+
+      search_facts(nil)
+    end
+  end
+end

data/puppet/spec/unit/indirector/node/puppetdb_spec.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+require 'puppet/indirector/node/puppetdb'
+require 'puppet/util/puppetdb/command_names'
+require 'json'
+
+describe Puppet::Node::Puppetdb do
+
+  CommandDeactivateNode = Puppet::Util::Puppetdb::CommandNames::CommandDeactivateNode
+
+  before :each do
+    Puppet::Node.indirection.stubs(:terminus).returns(subject)
+  end
+
+  let(:node) { "something.example.com" }
+  let(:producer_timestamp) { Time.now.iso8601(5) }
+
+  def destroy
+    Puppet::Node.indirection.destroy(node, {:producer_timestamp => producer_timestamp})
+  end
+
+  describe "#destroy" do
+    let(:response) { Net::HTTPOK.new('1.1', 200, 'OK') }
+    let(:http)     { mock 'http' }
+    before :each do
+      Puppet::Network::HttpPool.expects(:http_instance).returns http
+    end
+
+    it "should POST a '#{CommandDeactivateNode}' command" do
+      response.stubs(:body).returns '{"uuid": "a UUID"}'
+
+      payload = {
+        :command => CommandDeactivateNode,
+        :version => 3,
+        :payload => { :certname => node,
+                      :producer_timestamp => producer_timestamp },
+      }.to_json
+
+      http.expects(:post).with do |uri,body,headers|
+        expect(body).to eq(payload)
+      end.returns response
+
+      destroy
+    end
+
+    it "should log a deprecation warning if one is returned from PuppetDB" do
+      response['x-deprecation'] = 'A horrible deprecation warning!'
+      response.stubs(:body).returns '{"uuid": "a UUID"}'
+
+      Puppet.expects(:deprecation_warning).with do |msg|
+        msg =~ /A horrible deprecation warning!/
+      end
+
+      http.stubs(:post).returns response
+
+      destroy
+    end
+  end
+end

data/puppet/spec/unit/indirector/resource/puppetdb_spec.rb

@@ -0,0 +1,199 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/indirector/resource/puppetdb'
+require 'json'
+
+describe Puppet::Resource::Puppetdb do
+  before :each do
+    Puppet::Util::Puppetdb.stubs(:server).returns 'localhost'
+    Puppet::Util::Puppetdb.stubs(:port).returns 0
+    Puppet::Resource.indirection.stubs(:terminus).returns(subject)
+  end
+
+  describe "#search" do
+    let(:host) { 'default.local' }
+
+    def search(type)
+      # The API for creating scope objects is different between Puppet 2.7 and
+      # 3.0. The scope here isn't really used for anything relevant, so it's
+      # easiest to make it a stub to run against both versions of Puppet.
+      scope = stub('scope', :source => nil)
+      args = { :host => host, :filter => nil, :scope => scope }
+      Puppet::Resource.indirection.search(type, args)
+    end
+
+    it "should return an empty array if no resources match" do
+      response = Net::HTTPOK.new('1.1', 200, 'OK')
+      response.stubs(:body).returns '[]'
+
+      query = CGI.escape(["and", ["=", "type", "exec"], ["=", "exported", true], ["not", ["=", "certname", "default.local"]]].to_json)
+      http = stub 'http'
+      Puppet::Network::HttpPool.stubs(:http_instance).returns(http)
+      http.stubs(:get).with("/pdb/query/v4/resources?query=#{query}",  subject.headers).returns response
+
+      search("exec").should == []
+    end
+
+    it "should log a deprecation warning if one is returned from PuppetDB" do
+      response = Net::HTTPOK.new('1.1', 200, 'OK')
+      response['x-deprecation'] = "Deprecated, yo."
+
+      response.stubs(:body).returns '[]'
+
+      query = CGI.escape(["and", ["=", "type", "exec"], ["=", "exported", true], ["not", ["=", "certname", "default.local"]]].to_json)
+      http = stub 'http'
+      Puppet::Network::HttpPool.stubs(:http_instance).returns(http)
+      http.stubs(:get).with("/pdb/query/v4/resources?query=#{query}",  subject.headers).returns response
+
+      Puppet.expects(:deprecation_warning).with do |msg|
+        msg =~ /Deprecated, yo\./
+      end
+
+      search("exec")
+    end
+
+    it "should fail it can't connect to the PuppetDB server" do
+      expect { search("user") }.to raise_error(Puppet::Error, /Could not retrieve resources/)
+    end
+
+    describe "with a matching resource" do
+
+      let (:query) {
+          ['and',
+           ['=', 'type', 'File'],
+           ['=', 'exported', true],
+           ['not', ['=', 'certname', host]]]
+      }
+
+      def make_resource_hash(name, certname="localhost", exported=true)
+        metadata = { :file => '/etc/puppet/manifests/site.pp',
+                     :line => 10,
+                     :exported   => exported,
+                     :certname   => certname,
+                     :hash       => 'foobarbaz', }
+
+        res = Puppet::Type.type(:file).new(:title => File.expand_path(name),
+                                           :ensure => :present,
+                                           :mode => "0777")
+        params = res.to_hash
+        res_hash = metadata.merge(:type => res.type, :title => res.title)
+        res_hash.merge(:parameters => params)
+      end
+
+      def stub_response(resource_hashes)
+        body = resource_hashes.to_json
+
+        response = Net::HTTPOK.new('1.1', 200, 'OK')
+        response.stubs(:body).returns body
+
+        http = stub 'http'
+        Puppet::Network::HttpPool.stubs(:http_instance).returns(http)
+        http.stubs(:get).with("/pdb/query/v4/resources?query=#{CGI.escape(query.to_json)}",  subject.headers).returns response
+      end
+
+      context "with resources from a single host" do
+        before :each do
+          stub_response([make_resource_hash('foo'), make_resource_hash('bar')])
+        end
+
+
+        it "should return a list of parser resources if any resources are found" do
+          found = search('File')
+          found.length.should == 2
+          found.each do |item|
+            item.should be_a(Puppet::Parser::Resource)
+            item.type.should == 'File'
+            item[:ensure].should == 'present'
+            item[:mode].should == '777'
+          end
+        end
+
+
+        it "should not filter resources that have been found before" do
+          search('File').should == search('File')
+        end
+      end
+
+      context "with resources from multiple hosts" do
+        before :each do
+          stub_response([make_resource_hash('foo', 'localhost'), make_resource_hash('foo', 'remotehost')])
+        end
+
+        it "should supply unique collector_id vals for resources collected from different hosts" do
+          found = search('File')
+          found.length.should == 2
+          found[0].collector_id.should_not == found[1].collector_id
+        end
+      end
+
+
+    end
+  end
+
+  describe "#build_expression" do
+    it "should return nil if there is no filter" do
+      subject.build_expression(nil).should == nil
+    end
+
+    it "should fail if the filter uses an illegal operator" do
+      expect do
+        subject.build_expression(['foo', 'xor', 'bar'])
+      end.to raise_error(Puppet::Error, /not supported/)
+    end
+
+    it "should return an equal query if the operator is '='" do
+      subject.build_expression(['param','==','value']).should == ['=',['parameter','param'],'value']
+    end
+
+    it "should return a not-equal query if the operator is '!='" do
+      subject.build_expression(['param','!=','value']).should == ['not', ['=', ['parameter','param'],'value']]
+    end
+
+    it "should handle title correctly" do
+      subject.build_expression(['title','==','value']).should == ['=', 'title', 'value']
+    end
+
+    it "should preserve the case of title queries" do
+      subject.build_expression(['title','==','VALUE']).should == ['=', 'title', 'VALUE']
+    end
+
+    it "should handle tag correctly" do
+      subject.build_expression(['tag','==','value']).should == ['=', 'tag', 'value']
+    end
+
+    it "should generate lowercase tag queries for case-insensitivity" do
+      subject.build_expression(['tag','==','VALUE']).should == ['=', 'tag', 'value']
+    end
+
+    it "should conjoin 'and' queries with 'and'" do
+      query = [['tag', '==', 'one'], 'and', ['tag', '==', 'two']]
+      subject.build_expression(query).should == ['and',
+                                                  ['=', 'tag', 'one'],
+                                                  ['=', 'tag', 'two']]
+    end
+
+    it "should conjoin 'or' queries with 'or'" do
+      query = [['tag', '==', 'one'], 'or', ['tag', '==', 'two']]
+      subject.build_expression(query).should == ['or',
+                                                  ['=', 'tag', 'one'],
+                                                  ['=', 'tag', 'two']]
+    end
+
+    it "should construct complex, nested queries" do
+      query = [[['tag', '==', 'one'], 'and', ['tag', '==', 'two']], 'or', ['tag', '!=', 'three']]
+      subject.build_expression(query).should == ['or',
+                                                  ['and',
+                                                    ['=', 'tag', 'one'],
+                                                    ['=', 'tag', 'two']],
+                                                  ['not',
+                                                   ['=', 'tag', 'three']]]
+    end
+  end
+
+  describe "#headers" do
+    it "should accept the correct mime type" do
+      subject.headers['Accept'].should == 'application/json'
+    end
+  end
+end