Merge branch 'ticket/next/5166' into next

2 files changed, 162 insertions, 37 deletions

diff --git a/lib/puppet/indirector/inventory/yaml.rb b/lib/puppet/indirector/inventory/yaml.rb
index c6b1a14aa..fe3489a95 100644
--- a/lib/puppet/indirector/inventory/yaml.rb
+++ b/lib/puppet/indirector/inventory/yaml.rb
@@ -15,23 +15,7 @@ class Puppet::Node::Inventory::Yaml < Puppet::Indirector::Yaml
       type, name, operator = key.to_s.split(".")
       operator ||= 'eq'
 
-      next unless type == "facts"
-      return false unless facts.values[name]
-
-      return false unless case operator
-      when "eq"
-        facts.values[name].to_s == value.to_s
-      when "le"
-        facts.values[name].to_f <= value.to_f
-      when "ge"
-        facts.values[name].to_f >= value.to_f
-      when "lt"
-        facts.values[name].to_f < value.to_f
-      when "gt"
-        facts.values[name].to_f > value.to_f
-      when "ne"
-        facts.values[name].to_s != value.to_s
-      end
+      return false unless node_matches_option?(type, name, operator, value, facts)
     end
     return true
   end
@@ -44,4 +28,54 @@ class Puppet::Node::Inventory::Yaml < Puppet::Indirector::Yaml
     end
     node_names
   end
+
+  private
+
+  def node_matches_option?(type, name, operator, value, facts)
+    case type
+    when "meta"
+      case name
+      when "timestamp"
+        compare_timestamp(operator, facts.timestamp, Time.parse(value))
+      end
+    when "facts"
+      compare_facts(operator, facts.values[name], value)
+    end
+  end
+
+  def compare_facts(operator, value1, value2)
+    return false unless value1
+
+    case operator
+    when "eq"
+      value1.to_s == value2.to_s
+    when "le"
+      value1.to_f <= value2.to_f
+    when "ge"
+      value1.to_f >= value2.to_f
+    when "lt"
+      value1.to_f < value2.to_f
+    when "gt"
+      value1.to_f > value2.to_f
+    when "ne"
+      value1.to_s != value2.to_s
+    end
+  end
+
+  def compare_timestamp(operator, value1, value2)
+    case operator
+    when "eq"
+      value1 == value2
+    when "le"
+      value1 <= value2
+    when "ge"
+      value1 >= value2
+    when "lt"
+      value1 < value2
+    when "gt"
+      value1 > value2
+    when "ne"
+      value1 != value2
+    end
+  end
 end
diff --git a/spec/unit/indirector/inventory/yaml_spec.rb b/spec/unit/indirector/inventory/yaml_spec.rb
index 3a7035a9e..9f0c54353 100644
--- a/spec/unit/indirector/inventory/yaml_spec.rb
+++ b/spec/unit/indirector/inventory/yaml_spec.rb
@@ -7,7 +7,7 @@ require 'puppet/indirector/inventory/yaml'
 require 'puppet/indirector/request'
 
 describe Puppet::Node::Inventory::Yaml do
-  def setup_search_matching(matching, nonmatching, query)
+  def assert_search_matches(matching, nonmatching, query)
     request = Puppet::Indirector::Request.new(:inventory, :search, nil, query)
 
     Dir.stubs(:glob).returns(matching.keys + nonmatching.keys)
@@ -16,11 +16,11 @@ describe Puppet::Node::Inventory::Yaml do
         YAML.stubs(:load_file).with(key).returns value
       end
     end
-    return matching, request
+    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386", 'processor_count' => '4'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
       },
@@ -32,11 +32,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.architecture' => 'i386', 'facts.processor_count' => '4'}
     )
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return empty array when no nodes match the search query options" do
-    matching, request = setup_search_matching({}, {
+    assert_search_matches({}, {
         "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '10'),
         "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
         "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
@@ -44,12 +43,11 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.lt' => '4', 'facts.processor_count.gt' => '4'}
     )
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
 
   it "should return node names that match the search query options with the greater than operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
       },
@@ -60,12 +58,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.gt' => '4'}
     )
-
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options with the less than operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
       },
@@ -76,12 +72,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.lt' => '50'}
     )
-
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options with the less than or equal to operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
       },
@@ -92,12 +86,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.le' => '50'}
     )
-
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options with the greater than or equal to operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '100'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
       },
@@ -108,12 +100,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.ge' => '50'}
     )
-
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options with the not equal operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => 'arm'                           ),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
       },
@@ -124,7 +114,108 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.architecture.ne' => 'i386'}
     )
+  end
 
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+  def apply_timestamp(facts, timestamp)
+    facts.timestamp = timestamp
+    facts
+  end
+
+  it "should be able to query based on meta.timestamp.gt" do
+    assert_search_matches({
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+      },
+      {
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {'meta.timestamp.gt' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.le" do
+    assert_search_matches({
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+      },
+      {'meta.timestamp.le' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.lt" do
+    assert_search_matches({
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {'meta.timestamp.lt' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.ge" do
+    assert_search_matches({
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {'meta.timestamp.ge' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.eq" do
+    assert_search_matches({
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {'meta.timestamp.eq' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp" do
+    assert_search_matches({
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {'meta.timestamp' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.ne" do
+    assert_search_matches({
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {'meta.timestamp.ne' => '2010-10-15'}
+    )
   end
 end