ruby-puppetdb 1.6.1 → 2.0.0

data/lib/puppet/parser/functions/pdbresourcequery_all.rb

@@ -1,37 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:pdbresourcequery_all, :type => :rvalue, :doc => "\
-    Perform a PuppetDB resource query
-
-    The first argument is the resource query.
-    Second argument is optional but allows you to specify the item you want
-    from the returned hash.
-
-    Returns an array of hashes or array of strings if second argument is provided.
-
-    Examples:
-    # Return an array of hashes describing all files that are owned by root.
-    $ret = pdbresourcequery_all(
-      ['and',
-        ['=','type','File'],
-        ['=',['parameter','owner'],'root']])
-
-    # Return an array of host names having those resources
-    $ret = pdbresourcequery_all(
-      ['and',
-        ['=','type','File'],
-        ['=',['parameter','owner'],'root']], 'certname')") do |args|
-
-    raise(Puppet::ParseError, "pdbresourcequery_all(): Wrong number of arguments " +
-                "given (#{args.size} for 1 or 2)") if args.size < 1 or args.size > 2
-
-    Puppet::Parser::Functions.autoloader.load(:pdbquery) unless Puppet::Parser::Functions.autoloader.loaded?(:pdbquery)
-
-    resq, info = args
-    ret = function_pdbquery(['resources', resq])
-    if info then
-      ret.collect {|x| x[info]}
-    else
-      ret
-    end
-  end
-end

data/lib/puppet/parser/functions/pdbstatusquery.rb

@@ -1,31 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:pdbstatusquery, :type => :rvalue, :doc => "\
-    Perform a PuppetDB node status query
-
-    The first argument is the node to get the status for.
-    Second argument is optional, if specified only return that specific bit of
-    status, one of 'name', 'deactivated', 'catalog_timestamp' and 'facts_timestamp'.
-
-    Returns an array of hashes or a array of strings if second argument is supplied.
-
-    Examples:
-    # Get status for foo.example.com
-    pdbstatusquery('foo.example.com')
-    # Get catalog_timestamp for foo.example.com
-    pdbstatusquery('foo.example.com', 'catalog_timestamp')") do |args|
-
-    raise(Puppet::ParseError, "pdbquery(): Wrong number of arguments " +
-      "given (#{args.size} for 1 or 2)") if args.size < 1 or args.size > 2
-
-    Puppet::Parser::Functions.autoloader.load(:pdbquery) unless Puppet::Parser::Functions.autoloader.loaded?(:pdbquery)
-
-    node, status = args
-
-    ret = function_pdbquery(["status/nodes/#{node}"])
-    if status then
-      ret[status]
-    else
-      ret
-    end
-  end
-end

data/lib/puppetdb/util.rb

@@ -1,18 +0,0 @@
-class PuppetDB
-  module Util
-    def self.color(code)
-      colors = {:red => "",
-                :green => "",
-                :yellow => "",
-                :cyan => "",
-                :bold => "",
-                :reset => ""}
-
-      return colors[code] || ""
-    end
-
-    def self.colorize(code, msg)
-      "%s%s%s" % [ color(code), msg, color(:reset) ]
-    end
-  end
-end

data/spec/unit/puppet/parser/functions/pdbfactquery_spec.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the pdbfactquery function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    Puppet::Parser::Functions.function("pdbfactquery").should == "function_pdbfactquery"
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_pdbfactquery([]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are more than 2 arguments" do
-    lambda { scope.function_pdbfactquery([1, 2, 3]) }.should( raise_error(Puppet::ParseError))
-  end
-end

data/spec/unit/puppet/parser/functions/pdbnodequery_all_spec.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the pdbnodequery_all function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    Puppet::Parser::Functions.function("pdbnodequery_all").should == "function_pdbnodequery_all"
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_pdbnodequery_all([]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are more than 2 arguments" do
-    lambda { scope.function_pdbnodequery_all([1, 2, 3]) }.should( raise_error(Puppet::ParseError))
-  end
-end

data/spec/unit/puppet/parser/functions/pdbnodequery_spec.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the pdbnodequery function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    Puppet::Parser::Functions.function("pdbnodequery").should == "function_pdbnodequery"
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_pdbnodequery([]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are more than 2 arguments" do
-    lambda { scope.function_pdbnodequery([1, 2, 3]) }.should( raise_error(Puppet::ParseError))
-  end
-end

data/spec/unit/puppet/parser/functions/pdbquery_spec.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the pdbquery function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    Puppet::Parser::Functions.function("pdbquery").should == "function_pdbquery"
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_pdbquery([]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are more than 2 arguments" do
-    lambda { scope.function_pdbquery([1, 2, 3]) }.should( raise_error(Puppet::ParseError))
-  end
-end

data/spec/unit/puppet/parser/functions/pdbresourcequery_all_spec.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the pdbresourcequery_all function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    Puppet::Parser::Functions.function("pdbresourcequery_all").should == "function_pdbresourcequery_all"
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_pdbresourcequery_all([]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are more than 2 arguments" do
-    lambda { scope.function_pdbresourcequery_all([1, 2, 3]) }.should( raise_error(Puppet::ParseError))
-  end
-end

data/spec/unit/puppet/parser/functions/pdbresourcequery_spec.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the pdbresourcequery function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    Puppet::Parser::Functions.function("pdbresourcequery").should == "function_pdbresourcequery"
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_pdbresourcequery([]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are more than 2 arguments" do
-    lambda { scope.function_pdbresourcequery([1, 2, 3]) }.should( raise_error(Puppet::ParseError))
-  end
-end

data/spec/unit/puppet/parser/functions/pdbstatusquery_spec.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the pdbstatusquery function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    Puppet::Parser::Functions.function("pdbstatusquery").should == "function_pdbstatusquery"
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    lambda { scope.function_pdbstatusquery([]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if there are more than 2 arguments" do
-    lambda { scope.function_pdbstatusquery([1, 2, 3]) }.should( raise_error(Puppet::ParseError))
-  end
-end

data/spec/unit/puppetdb/connection_spec.rb

@@ -1,67 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-require 'puppetdb/connection'
-
-describe PuppetDB::Connection do
-  context "Query parsing" do
-    let(:connection) { PuppetDB::Connection.new }
-    it "should handle empty queries" do
-      connection.parse_query('').should be_nil
-    end
-
-    it "should handle double quoted strings" do
-      connection.parse_query('foo="bar"').should eq ["in", "name", ["extract", "certname", ["select-facts", ["and", ["=", "name", "foo"], ["=", "value", "bar"]]]]]
-    end
-
-    it "should handle single quoted strings" do
-      connection.parse_query('foo=\'bar\'').should eq ["in", "name", ["extract", "certname", ["select-facts", ["and", ["=", "name", "foo"], ["=", "value", "bar"]]]]]
-    end
-
-    it "should handle precedence" do
-      connection.parse_query('foo=1 or bar=2 and baz=3').should eq ["or", ["in", "name", ["extract", "certname", ["select-facts", ["and", ["=", "name", "foo"], ["=", "value", 1]]]]], ["and", ["in", "name", ["extract", "certname", ["select-facts", ["and", ["=", "name", "bar"], ["=", "value", 2]]]]], ["in", "name", ["extract", "certname", ["select-facts", ["and", ["=", "name", "baz"], ["=", "value", 3]]]]]]]
-      connection.parse_query('(foo=1 or bar=2) and baz=3').should eq ["and", ["or", ["in", "name", ["extract", "certname", ["select-facts", ["and", ["=", "name", "foo"], ["=", "value", 1]]]]], ["in", "name", ["extract", "certname", ["select-facts", ["and", ["=", "name", "bar"], ["=", "value", 2]]]]]], ["in", "name", ["extract", "certname", ["select-facts", ["and", ["=", "name", "baz"], ["=", "value", 3]]]]]]
-    end
-
-    it "should parse resource queries with only type name" do
-      connection.parse_query('file').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", false], ["=", "type", "File"]]]]]
-    end
-
-    it "should parse resource queries with only title" do
-      connection.parse_query('[foo]').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", false], ["=", "title", "foo"]]]]]
-    end
-
-    it "should parse resource queries with only parameters" do
-      connection.parse_query('{foo=bar}').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", false], ["=", ["parameter", "foo"], "bar"]]]]]
-    end
-
-    it "should parse resource queries for exported resources" do
-      connection.parse_query('@@file').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", true], ["=", "type", "File"]]]]]
-    end
-
-    it "should parse resource queries with type, title and parameters" do
-      connection.parse_query('file[foo]{bar=baz}').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", false], ["=", "type", "File"], ["=", "title", "foo"], ["=", ["parameter", "bar"], "baz"]]]]]
-    end
-
-    it "should parse resource queries with tags" do
-      connection.parse_query('file[foo]{tag=baz}').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", false], ["=", "type", "File"], ["=", "title", "foo"], ["=", "tag", "baz"]]]]]
-    end
-
-    it "should handle precedence within resource parameter queries" do
-      connection.parse_query('{foo=1 or bar=2 and baz=3}').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", false], ["or", ["=", ["parameter", "foo"], 1], ["and", ["=", ["parameter", "bar"], 2], ["=", ["parameter", "baz"], 3]]]]]]]
-      connection.parse_query('{(foo=1 or bar=2) and baz=3}').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", false], ["or", ["=", ["parameter", "foo"], 1], ["=", ["parameter", "bar"], 2]], ["=", ["parameter", "baz"], 3]]]]]
-    end
-
-    it "should capitalize class names" do
-      connection.parse_query('class[foo::bar]').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", false], ["=", "type", "Class"], ["=", "title", "Foo::Bar"]]]]]
-    end
-
-    it "should parse resource queries with regeexp title matching" do
-      connection.parse_query('[~foo]').should eq ["in", "name", ["extract", "certname", ["select-resources", ["and", ["=", "exported", false], ["~", "title", "foo"]]]]]
-    end
-
-    it "should be able to negate expressions" do
-      connection.parse_query('not foo=bar').should eq ["not", ["in", "name", ["extract", "certname", ["select-facts", ["and", ["=", "name", "foo"], ["=", "value", "bar"]]]]]]
-    end
-  end
-end