ruby-puppetdb 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ed96d47f9a2eae2e54dccea8d9961cd185d0631
-  data.tar.gz: dc1ba65a4259f59d583dda883957b3bc5127df4a
+  metadata.gz: 9f199ac32e1da71ed00c19f6b157660787d08a86
+  data.tar.gz: 53c9970cb340bc587b2b3cdec6aaeda8133c5e40
 SHA512:
-  metadata.gz: 15f7ae9d9c39d487f772ea24d46229dfced946265d9fd52e5b7603a319eeb420c335d57ce618ab45344b47cfa10728645ddacf9a79d3b02ab6f6cb39ec961e94
-  data.tar.gz: 79e0500fd751c24e7ca74d5df6342d4eb76b8b2f1721672472d2d99832d6d4a87a654c49cd3c3a375aa327919f535bd3099d926b925171ccf5559d8159b95f85
+  metadata.gz: 385d225ca591427dde487a9d9a3232cc016b936c7c9014394361bee489109c6b963a5ab141e3dd3f76b5c0819ad04b3dea8edaae093b93236fd9c584f459d8f1
+  data.tar.gz: afbb1e20ae8091011201d092aadfb6a7696b680cac65a7d3cc49800b986d37d88398655c382ae7266b63f3b5b0e81507eebe292afca72dad29430e2f70792fc9

data/lib/puppet/functions/query_facts.rb

@@ -0,0 +1,38 @@
+# Accepts two arguments, a query used to discover nodes, and a list of facts
+# that should be returned from those hosts.
+#
+# The query specified should conform to the following format:
+#   (Type[title] and fact_name<operator>fact_value) or ...
+#   Package[mysql-server] and cluster_id=my_first_cluster
+#
+# The facts list provided should be an array of fact names.
+#
+# The result is a hash that maps the name of the nodes to a hash of facts that
+# contains the facts specified.
+Puppet::Functions.create_function('query_facts')  do
+  require 'puppet/util/puppetdb'
+
+  # This is needed if the puppetdb library isn't pluginsynced to the master
+  $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  begin
+    require 'puppetdb/connection'
+  ensure
+    $LOAD_PATH.shift
+  end
+
+  dispatch :query_facts do
+    param 'Variant[String, Array]', :query
+    param 'Array[String, 1]', :facts
+  end
+
+  def query_facts(query, facts)
+    facts = facts.map { |fact| fact.match(/\./) ? fact.split('.') : fact }
+    facts_for_query = facts.map { |fact| fact.is_a?(Array) ? fact.first : fact }
+
+    uri = URI(Puppet::Util::Puppetdb.config.server_urls.first)
+    puppetdb = PuppetDB::Connection.new(uri.host, uri.port, uri.scheme == 'https')
+    parser = PuppetDB::Parser.new
+    query = parser.facts_query query, facts_for_query if query.is_a? String
+    parser.facts_hash(puppetdb.query(:facts, query, :extract => [:certname, :name, :value]), facts)
+  end
+end

data/lib/puppet/functions/query_nodes.rb

@@ -0,0 +1,62 @@
+# Accepts two arguments, a query used to discover nodes, and an optional
+# fact that should be returned.
+#
+# The query specified should conform to the following format:
+#   (Type[title] and fact_name<operator>fact_value) or ...
+#    Package["mysql-server"] and cluster_id=my_first_cluster
+#
+# The second argument should be single fact or series of keys joined on periods
+# (this argument is optional)
+Puppet::Functions.create_function('query_nodes') do
+  require 'puppet/util/puppetdb'
+
+  # This is needed if the puppetdb library isn't pluginsynced to the master
+  $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  begin
+    require 'puppetdb/connection'
+  ensure
+    $LOAD_PATH.shift
+  end
+
+  dispatch :query_nodes do
+    param 'Variant[String, Array]', :query
+  end
+
+  dispatch :query_nodes_fact do
+    param 'Variant[String, Array]', :query
+    param 'String', :fact
+  end
+
+  def parser
+    @parser ||= PuppetDB::Parser.new
+  end
+
+  def puppetdb
+    @uri ||= URI(Puppet::Util::Puppetdb.config.server_urls.first)
+    @puppetdb ||= PuppetDB::Connection.new(
+      @uri.host,
+      @uri.port,
+      @uri.scheme == 'https'
+    )
+  end
+
+  def query_nodes(query)
+    query = parser.parse(query, :nodes) if query.is_a? String
+    puppetdb.query(:nodes, query, :extract => :certname).collect do |n|
+      n['certname']
+    end
+  end
+
+  def query_nodes_fact(query, fact)
+    fact_for_query = fact.split('.').first
+
+    query = parser.facts_query(query, [fact_for_query])
+    response = puppetdb.query(:facts, query, :extract => :value)
+
+    if fact.split('.').size > 1
+      parser.extract_nested_fact(response, fact.split('.')[1..-1])
+    else
+      response.collect { |f| f['value'] }
+    end
+  end
+end

data/lib/puppetdb.rb

@@ -1,4 +1,4 @@
 module PuppetDB
   # Current version of this module
-  VERSION ||= [2, 2, 0]
+  VERSION ||= [2, 3, 0].freeze
 end

data/spec/unit/puppetdb/parser_spec.rb

@@ -7,11 +7,11 @@ describe PuppetDB::Parser do
   context 'Query parsing' do
     let(:parser) { PuppetDB::Parser.new }
     it 'should handle empty queries' do
-      parser.parse('').should be_nil
+      expect(parser.parse('')).to be_nil
     end
 
     it 'should handle double quoted strings' do
-      parser.parse('foo="bar"').should eq \
+      expect(parser.parse('foo="bar"')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -21,7 +21,7 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle single quoted strings' do
-      parser.parse('foo=\'bar\'').should eq \
+      expect(parser.parse('foo=\'bar\'')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -31,7 +31,7 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle = operator' do
-      parser.parse('foo=bar').should eq \
+      expect(parser.parse('foo=bar')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -41,7 +41,7 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle != operator' do
-      parser.parse('foo!=bar').should eq \
+      expect(parser.parse('foo!=bar')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -51,7 +51,7 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle ~ operator' do
-      parser.parse('foo~bar').should eq \
+      expect(parser.parse('foo~bar')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -61,7 +61,7 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle !~ operator' do
-      parser.parse('foo!~bar').should eq \
+      expect(parser.parse('foo!~bar')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -71,7 +71,7 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle >= operator' do
-      parser.parse('foo>=1').should eq \
+      expect(parser.parse('foo>=1')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -81,7 +81,7 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle <= operator' do
-      parser.parse('foo<=1').should eq \
+      expect(parser.parse('foo<=1')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -91,7 +91,7 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle > operator' do
-      parser.parse('foo>1').should eq \
+      expect(parser.parse('foo>1')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -101,7 +101,7 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle < operator' do
-      parser.parse('foo<1').should eq \
+      expect(parser.parse('foo<1')).to eq \
         ['in', 'certname',
          ['extract', 'certname',
           ['select_fact_contents',
@@ -111,111 +111,111 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle precedence' do
-      parser.parse('foo=1 or bar=2 and baz=3').should eq ['or', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo']], ['=', 'value', 1]]]]], ['and', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['bar']], ['=', 'value', 2]]]]], ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['baz']], ['=', 'value', 3]]]]]]]
-      parser.parse('(foo=1 or bar=2) and baz=3').should eq ['and', ['or', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo']], ['=', 'value', 1]]]]], ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['bar']], ['=', 'value', 2]]]]]], ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['baz']], ['=', 'value', 3]]]]]]
+      expect(parser.parse 'foo=1 or bar=2 and baz=3').to eq ['or', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo']], ['=', 'value', 1]]]]], ['and', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['bar']], ['=', 'value', 2]]]]], ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['baz']], ['=', 'value', 3]]]]]]]
+      expect(parser.parse '(foo=1 or bar=2) and baz=3').to eq ['and', ['or', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo']], ['=', 'value', 1]]]]], ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['bar']], ['=', 'value', 2]]]]]], ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['baz']], ['=', 'value', 3]]]]]]
     end
 
     it 'should parse resource queries for exported resources' do
-      parser.parse('@@file[foo]').should eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', true]]]]]
+      expect(parser.parse '@@file[foo]').to eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', true]]]]]
     end
 
     it 'should parse resource queries with type, title and parameters' do
-      parser.parse('file[foo]{bar=baz}').should eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', false], ['=', %w(parameter bar), 'baz']]]]]
+      expect(parser.parse('file[foo]{bar=baz}')).to eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', false], ['=', %w(parameter bar), 'baz']]]]]
     end
 
     it 'should parse resource queries with tags' do
-      parser.parse('file[foo]{tag=baz}').should eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', false], ['=', 'tag', 'baz']]]]]
+      expect(parser.parse('file[foo]{tag=baz}')).to eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', false], ['=', 'tag', 'baz']]]]]
     end
 
     it 'should handle precedence within resource parameter queries' do
-      parser.parse('file[foo]{foo=1 or bar=2 and baz=3}').should eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', false], ['or', ['=', %w(parameter foo), 1], ['and', ['=', %w(parameter bar), 2], ['=', %w(parameter baz), 3]]]]]]]
-      parser.parse('file[foo]{(foo=1 or bar=2) and baz=3}').should eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', false], ['and', ['or', ['=', %w(parameter foo), 1], ['=', %w(parameter bar), 2]], ['=', %w(parameter baz), 3]]]]]]
+      expect(parser.parse('file[foo]{foo=1 or bar=2 and baz=3}')).to eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', false], ['or', ['=', %w(parameter foo), 1], ['and', ['=', %w(parameter bar), 2], ['=', %w(parameter baz), 3]]]]]]]
+      expect(parser.parse('file[foo]{(foo=1 or bar=2) and baz=3}')).to eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'File'], ['=', 'title', 'foo'], ['=', 'exported', false], ['and', ['or', ['=', %w(parameter foo), 1], ['=', %w(parameter bar), 2]], ['=', %w(parameter baz), 3]]]]]]
     end
 
     it 'should capitalize class names' do
-      parser.parse('class[foo::bar]').should eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'Class'], ['=', 'title', 'Foo::Bar'], ['=', 'exported', false]]]]]
+      expect(parser.parse('class[foo::bar]')).to eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'Class'], ['=', 'title', 'Foo::Bar'], ['=', 'exported', false]]]]]
     end
 
     it 'should parse resource queries with regeexp title matching' do
-      parser.parse('class[~foo]').should eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'Class'], ['~', 'title', 'foo'], ['=', 'exported', false]]]]]
+      expect(parser.parse('class[~foo]')).to eq ['in', 'certname', ['extract', 'certname', ['select_resources', ['and', ['=', 'type', 'Class'], ['~', 'title', 'foo'], ['=', 'exported', false]]]]]
     end
 
     it 'should be able to negate expressions' do
-      parser.parse('not foo=bar').should eq ['not', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo']], ['=', 'value', 'bar']]]]]]
+      expect(parser.parse('not foo=bar')).to eq ['not', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo']], ['=', 'value', 'bar']]]]]]
     end
 
     it 'should handle single string expressions' do
-      parser.parse('foo.bar.com').should eq ['~', 'certname', 'foo\\.bar\\.com']
+      expect(parser.parse('foo.bar.com')).to eq ['~', 'certname', 'foo\\.bar\\.com']
     end
 
     it 'should handle structured facts' do
-      parser.parse('foo.bar=baz').should eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', %w(foo bar)], ['=', 'value', 'baz']]]]]
+      expect(parser.parse('foo.bar=baz')).to eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', %w(foo bar)], ['=', 'value', 'baz']]]]]
     end
 
     it 'should handle structured facts with array component' do
-      parser.parse('foo.bar.0=baz').should eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo', 'bar', 0]], ['=', 'value', 'baz']]]]]
+      expect(parser.parse('foo.bar.0=baz')).to eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo', 'bar', 0]], ['=', 'value', 'baz']]]]]
     end
 
     it 'should handle structured facts with match operator' do
-      parser.parse('foo.bar.~".*"=baz').should eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['~>', 'path', ['foo', 'bar', '.*']], ['=', 'value', 'baz']]]]]
+      expect(parser.parse('foo.bar.~".*"=baz')).to eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['~>', 'path', ['foo', 'bar', '.*']], ['=', 'value', 'baz']]]]]
     end
 
     it 'should handle structured facts with wildcard operator' do
-      parser.parse('foo.bar.*=baz').should eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['~>', 'path', ['foo', 'bar', '.*']], ['=', 'value', 'baz']]]]]
+      expect(parser.parse('foo.bar.*=baz')).to eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['~>', 'path', ['foo', 'bar', '.*']], ['=', 'value', 'baz']]]]]
     end
 
     it 'should handle #node subqueries' do
-      parser.parse('#node.catalog_environment=production').should eq ['in', 'certname', ['extract', 'certname', ['select_nodes', ['=', 'catalog_environment', 'production']]]]
+      expect(parser.parse('#node.catalog_environment=production')).to eq ['in', 'certname', ['extract', 'certname', ['select_nodes', ['=', 'catalog_environment', 'production']]]]
     end
 
     it 'should handle #node subqueries with block of conditions' do
-      parser.parse('#node { catalog_environment=production }').should eq ['in', 'certname', ['extract', 'certname', ['select_nodes', ['=', 'catalog_environment', 'production']]]]
+      expect(parser.parse('#node { catalog_environment=production }')).to eq ['in', 'certname', ['extract', 'certname', ['select_nodes', ['=', 'catalog_environment', 'production']]]]
     end
 
     it 'should handle #node subquery combined with fact query' do
-      parser.parse('#node.catalog_environment=production and foo=bar').should eq ['and', ['in', 'certname', ['extract', 'certname', ['select_nodes', ['=', 'catalog_environment', 'production']]]], ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo']], ['=', 'value', 'bar']]]]]]
+      expect(parser.parse('#node.catalog_environment=production and foo=bar')).to eq ['and', ['in', 'certname', ['extract', 'certname', ['select_nodes', ['=', 'catalog_environment', 'production']]]], ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['foo']], ['=', 'value', 'bar']]]]]]
     end
 
     it 'should escape non match parts on structured facts with match operator' do
-      parser.parse('"foo.bar".~".*"=baz').should eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['~>', 'path', ['foo\\.bar', '.*']], ['=', 'value', 'baz']]]]]
+      expect(parser.parse('"foo.bar".~".*"=baz')).to eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['~>', 'path', ['foo\\.bar', '.*']], ['=', 'value', 'baz']]]]]
     end
 
     it 'should parse dates in queries' do
       date = Time.new(2014, 9, 9).utc.strftime('%FT%TZ')
-      parser.parse('#node.report_timestamp<@"Sep 9, 2014"').should eq ['in', 'certname', ['extract', 'certname', ['select_nodes', ['<', 'report_timestamp', date]]]]
+      expect(parser.parse('#node.report_timestamp<@"Sep 9, 2014"')).to eq ['in', 'certname', ['extract', 'certname', ['select_nodes', ['<', 'report_timestamp', date]]]]
     end
 
     it 'should not wrap it in a subquery if mode is :none' do
-      parser.parse('class[apache]', :none).should eq ["and", ["=", "type", "Class"], ["=", "title", "Apache"], ["=", "exported", false]]
+      expect(parser.parse 'class[apache]', :none).to eq ["and", ["=", "type", "Class"], ["=", "title", "Apache"], ["=", "exported", false]]
     end
   end
 
   context 'facts_query' do
     let(:parser) { PuppetDB::Parser.new }
     it 'should return a query for all if no facts are specified' do
-      parser.facts_query('kernel=Linux').should eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['kernel']], ['=', 'value', 'Linux']]]]]
+      expect(parser.facts_query 'kernel=Linux').to eq ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['kernel']], ['=', 'value', 'Linux']]]]]
     end
 
     it 'should return a query for specific facts if they are specified' do
-      parser.facts_query('kernel=Linux', ['ipaddress']). should eq ['and', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['kernel']], ['=', 'value', 'Linux']]]]], ['or', ['=', 'name', 'ipaddress']]]
+      expect(parser.facts_query 'kernel=Linux', ['ipaddress']).to eq ['and', ['in', 'certname', ['extract', 'certname', ['select_fact_contents', ['and', ['=', 'path', ['kernel']], ['=', 'value', 'Linux']]]]], ['or', ['=', 'name', 'ipaddress']]]
     end
 
     it 'should return a query for matching facts on all nodes if query is missing' do
-      parser.facts_query('', ['ipaddress']).should eq ['or', ['=', 'name', 'ipaddress']]
+      expect(parser.facts_query('', ['ipaddress'])).to eq ['or', ['=', 'name', 'ipaddress']]
     end
   end
 
   context 'facts_hash' do
     let(:parser) { PuppetDB::Parser.new }
     it 'should merge facts into a nested hash' do
-      parser.facts_hash([
+      expect(parser.facts_hash([
         { 'certname' => 'ip-172-31-45-32.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'kernel', 'value' => 'Linux' },
         { 'certname' => 'ip-172-31-33-234.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'kernel', 'value' => 'Linux' },
         { 'certname' => 'ip-172-31-5-147.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'kernel', 'value' => 'Linux' },
         { 'certname' => 'ip-172-31-45-32.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'fqdn', 'value' => 'ip-172-31-45-32.eu-west-1.compute.internal' },
         { 'certname' => 'ip-172-31-33-234.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'fqdn', 'value' => 'ip-172-31-33-234.eu-west-1.compute.internal' },
         { 'certname' => 'ip-172-31-5-147.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'fqdn', 'value' => 'ip-172-31-5-147.eu-west-1.compute.internal' }
-      ], ['kernel', 'fqdn']).should eq(
+      ], ['kernel', 'fqdn'])).to eq(
         'ip-172-31-45-32.eu-west-1.compute.internal' => { 'kernel' => 'Linux', 'fqdn' => 'ip-172-31-45-32.eu-west-1.compute.internal' },
         'ip-172-31-33-234.eu-west-1.compute.internal' => { 'kernel' => 'Linux', 'fqdn' => 'ip-172-31-33-234.eu-west-1.compute.internal' },
         'ip-172-31-5-147.eu-west-1.compute.internal' => { 'kernel' => 'Linux', 'fqdn' => 'ip-172-31-5-147.eu-west-1.compute.internal' }
@@ -223,12 +223,12 @@ describe PuppetDB::Parser do
     end
 
     it 'should handle nested facts' do
-      parser.facts_hash([
+      expect(parser.facts_hash([
         { 'certname' => 'ip-172-31-45-32.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'kernel', 'value' => 'Linux' },
         { 'certname' => 'ip-172-31-33-234.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'kernel', 'value' => 'Linux' },
         { 'certname' => 'ip-172-31-45-32.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'networking', 'value' => { 'interfaces' => { 'eth0' => { 'ip' => '172.31.45.32' } } } },
         { 'certname' => 'ip-172-31-33-234.eu-west-1.compute.internal', 'environment' => 'production', 'name' => 'networking', 'value' => { 'interfaces' => { 'eth0' => { 'ip' => '172.31.33.234' } } } },
-      ], ['kernel', ['networking', 'interfaces', 'eth0', 'ip']]).should eq(
+      ], ['kernel', ['networking', 'interfaces', 'eth0', 'ip']])).to eq(
         'ip-172-31-45-32.eu-west-1.compute.internal' => { 'kernel' => 'Linux', 'networking_interfaces_eth0_ip' => '172.31.45.32' },
         'ip-172-31-33-234.eu-west-1.compute.internal' => { 'kernel' => 'Linux', 'networking_interfaces_eth0_ip' => '172.31.33.234' },
       )
@@ -237,7 +237,7 @@ describe PuppetDB::Parser do
 
   context 'extract' do
     it 'should create an extract query' do
-      PuppetDB::ParserHelper.extract(:certname, :name, ['=', 'certname', 'foo.example.com']).should eq(
+      expect(PuppetDB::ParserHelper.extract(:certname, :name, ['=', 'certname', 'foo.example.com'])).to eq(
         ['extract', ['certname', 'name'], ['=', 'certname', 'foo.example.com']]
       )
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-puppetdb
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Erik Dalen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-14 00:00:00.000000000 Z
+date: 2017-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -64,56 +64,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: rspec-expectations
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.5'
 - !ruby/object:Gem::Dependency
   name: rspec-puppet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.2'
 - !ruby/object:Gem::Dependency
   name: puppetlabs_spec_helper
   requirement: !ruby/object:Gem::Requirement
@@ -146,16 +146,16 @@ dependencies:
   name: rexical
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: puppet-blacksmith
   requirement: !ruby/object:Gem::Requirement
@@ -185,6 +185,8 @@ files:
 - lib/hiera/backend/puppetdb_backend.rb
 - lib/puppet/application/query.rb
 - lib/puppet/face/query.rb
+- lib/puppet/functions/query_facts.rb
+- lib/puppet/functions/query_nodes.rb
 - lib/puppet/parser/functions/query_facts.rb
 - lib/puppet/parser/functions/query_nodes.rb
 - lib/puppet/parser/functions/query_resources.rb
@@ -227,12 +229,12 @@ signing_key:
 specification_version: 4
 summary: Query functions for PuppetDB
 test_files:
+- spec/puppet/util/puppetdb.rb
 - spec/spec_helper.rb
+- spec/unit/puppetdb/parser_spec.rb
 - spec/functions/query_facts_spec.rb
 - spec/functions/query_nodes_spec.rb
 - spec/functions/query_resources_spec.rb
-- spec/unit/puppetdb/parser_spec.rb
-- spec/puppet/util/puppetdb.rb
 - examples/nova_functions.pp
-- examples/query_node_examples.pp
 - examples/query_resource_examples.pp
+- examples/query_node_examples.pp