puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/file_system/path_pattern_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet/file_system'
-
-describe Puppet::FileSystem::PathPattern do
-  include PuppetSpec::Files
-  InvalidPattern = Puppet::FileSystem::PathPattern::InvalidPattern
-
-  describe 'relative' do
-    it "can not be created with a traversal up the directory tree" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("my/../other")
-      end.to raise_error(InvalidPattern, "PathPatterns cannot be created with directory traversals.")
-    end
-
-    it "can be created with a '..' prefixing a filename" do
-      Puppet::FileSystem::PathPattern.relative("my/..other").to_s.should eq("my/..other")
-    end
-
-    it "can be created with a '..' suffixing a filename" do
-      Puppet::FileSystem::PathPattern.relative("my/other..").to_s.should eq("my/other..")
-    end
-
-    it "can be created with a '..' embedded in a filename" do
-      Puppet::FileSystem::PathPattern.relative("my/ot..her").to_s.should eq("my/ot..her")
-    end
-
-    it "can not be created with a \\0 byte embedded" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("my/\0/other")
-      end.to raise_error(InvalidPattern, /PathPatterns cannot be created with a zero byte./)
-    end
-
-    it "can not be created with a windows drive" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("c:\\relative\\path")
-      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
-    end
-
-    it "can not be created with a windows drive (with space)" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative(" c:\\relative\\path")
-      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be prefixed with a drive.")
-    end
-
-    it "can not create an absolute relative path" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("/no/absolutes")
-      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
-    end
-
-    it "can not create an absolute relative path (with space)" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("\t/no/absolutes")
-      end.to raise_error(InvalidPattern, "A relative PathPattern cannot be an absolute path.")
-    end
-
-    it "can not create a relative path that is a windows path relative to the current drive" do
-      expect do
-        Puppet::FileSystem::PathPattern.relative("\\no\relatives")
-      end.to raise_error(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
-    end
-
-    it "creates a relative PathPattern from a valid relative path" do
-      Puppet::FileSystem::PathPattern.relative("a/relative/path").to_s.should eq("a/relative/path")
-    end
-
-    it "is not absolute" do
-      Puppet::FileSystem::PathPattern.relative("a/relative/path").should_not be_absolute
-    end
-  end
-
-  describe 'absolute' do
-    it "can not create a relative absolute path" do
-      expect do
-        Puppet::FileSystem::PathPattern.absolute("no/relatives")
-      end.to raise_error(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
-    end
-
-    it "can not create an absolute path that is a windows path relative to the current drive" do
-      expect do
-        Puppet::FileSystem::PathPattern.absolute("\\no\\relatives")
-      end.to raise_error(InvalidPattern, "A PathPattern cannot be a Windows current drive relative path.")
-    end
-
-    it "creates an absolute PathPattern from a valid absolute path" do
-      Puppet::FileSystem::PathPattern.absolute("/an/absolute/path").to_s.should eq("/an/absolute/path")
-    end
-
-    it "creates an absolute PathPattern from a valid Windows absolute path" do
-      Puppet::FileSystem::PathPattern.absolute("c:/absolute/windows/path").to_s.should eq("c:/absolute/windows/path")
-    end
-
-    it "is absolute" do
-      Puppet::FileSystem::PathPattern.absolute("c:/absolute/windows/path").should be_absolute
-    end
-
-    it "can be created with a '..' embedded in a filename on windows", :if => Puppet.features.microsoft_windows? do
-      Puppet::FileSystem::PathPattern.absolute(%q{c:\..my\ot..her\one..}).to_s.should eq(%q{c:\..my\ot..her\one..})
-    end
-  end
-
-  it "prefixes the relative path pattern with another path" do
-    pattern = Puppet::FileSystem::PathPattern.relative("docs/*_thoughts.txt")
-    prefix = Puppet::FileSystem::PathPattern.absolute("/prefix")
-
-    absolute_pattern = pattern.prefix_with(prefix)
-
-    absolute_pattern.should be_absolute
-    absolute_pattern.to_s.should eq(File.join("/prefix", "docs/*_thoughts.txt"))
-  end
-
-  it "refuses to prefix with a relative pattern" do
-    pattern = Puppet::FileSystem::PathPattern.relative("docs/*_thoughts.txt")
-    prefix = Puppet::FileSystem::PathPattern.relative("prefix")
-
-    expect do
-      pattern.prefix_with(prefix)
-    end.to raise_error(InvalidPattern, "An absolute PathPattern cannot be a relative path.")
-  end
-
-  it "applies the pattern to the filesystem as a glob" do
-    dir = tmpdir('globtest')
-    create_file_in(dir, "found_one")
-    create_file_in(dir, "found_two")
-    create_file_in(dir, "third_not_found")
-
-    pattern = Puppet::FileSystem::PathPattern.relative("found_*").prefix_with(
-      Puppet::FileSystem::PathPattern.absolute(dir))
-
-    pattern.glob.should include(File.join(dir, "found_one"))
-    pattern.glob.should include(File.join(dir, "found_two"))
-    pattern.glob.should_not include(File.join(dir, "third_not_found"))
-  end
-
-  def create_file_in(dir, name)
-    File.open(File.join(dir, name), "w") { |f| f.puts "data" }
-  end
-end

data/spec/unit/indirector/catalog/static_compiler_spec.rb

@@ -1,194 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'puppet/indirector/catalog/static_compiler'
-require 'puppet/file_serving/metadata'
-require 'puppet/file_serving/content'
-require 'yaml'
-
-describe Puppet::Resource::Catalog::StaticCompiler do
-  before :all do
-    @num_file_resources = 10
-  end
-
-  let(:request) do
-    Puppet::Indirector::Request.new(:the_indirection_named_foo,
-                                    :find,
-                                    "the-node-named-foo",
-                                    :environment => "production")
-  end
-
-  describe "#find" do
-    it "returns a catalog" do
-      subject.find(request).should be_a_kind_of(Puppet::Resource::Catalog)
-    end
-
-    it "returns nil if there is no compiled catalog" do
-      compiler = mock('compiler indirection')
-      compiler.expects(:find).with(request).returns(nil)
-
-      subject.expects(:compiler).returns(compiler)
-      subject.find(request).should be_nil
-    end
-
-    describe "a catalog with file resources containing source parameters with puppet:// URIs" do
-      it "filters file resource source URI's to checksums" do
-        stub_the_compiler
-        resource_catalog = subject.find(request)
-        resource_catalog.resources.each do |resource|
-          next unless resource.type == "File"
-          resource[:content].should == "{md5}361fadf1c712e812d198c4cab5712a79"
-          resource[:source].should be_nil
-        end
-      end
-
-      it "does not modify file resources with non-puppet:// URI's" do
-        uri = "/this/is/not/a/puppet/uri.txt"
-        stub_the_compiler(:source => uri)
-        resource_catalog = subject.find(request)
-        resource_catalog.resources.each do |resource|
-          next unless resource.type == "File"
-          resource[:content].should be_nil
-          resource[:source].should == uri
-        end
-      end
-
-      it "copies the owner, group and mode from the fileserer" do
-        stub_the_compiler
-        resource_catalog = subject.find(request)
-        resource_catalog.resources.each do |resource|
-          next unless resource.type == "File"
-          resource[:owner].should == 0
-          resource[:group].should == 0
-          resource[:mode].should  == 420
-        end
-      end
-    end
-  end
-
-  describe "(#15193) when storing content to the filebucket" do
-    it "explicitly uses the indirection method" do
-      # Do not stub the store_content method which is stubbed by default in the
-      # value of the stub_methods option.
-      stub_the_compiler(:stub_methods => false)
-
-      # We expect the content to be retrieved from the FileServer ...
-      fake_content = mock('FileServer Content')
-      fake_content.expects(:content).returns("HELLO WORLD")
-
-      # Mock the FileBucket to behave as if the file content does not exist.
-      # NOTE, we're simulating the first call returning false, indicating the
-      # file is not present, then all subsequent calls returning true.  This
-      # mocked behavior is intended to replicate the real behavior of the same
-      # file being stored to the filebucket multiple times.
-      Puppet::FileBucket::File.indirection.
-        expects(:find).times(@num_file_resources).
-        returns(false).then.returns(true)
-
-      Puppet::FileServing::Content.indirection.
-        expects(:find).once.
-        returns(fake_content)
-
-      # Once retrived from the FileServer, we expect the file to be stored into
-      # the FileBucket only once.  All of the file resources in the fake
-      # catalog have the same content.
-      Puppet::FileBucket::File.indirection.expects(:save).once.with do |file|
-        file.contents == "HELLO WORLD"
-      end
-
-      # Obtain the Static Catalog
-      resource_catalog = subject.find(request)
-
-      # Ensure all of the file resources were filtered
-      resource_catalog.resources.each do |resource|
-        next unless resource.type == "File"
-        resource[:content].should == "{md5}361fadf1c712e812d198c4cab5712a79"
-        resource[:source].should be_nil
-      end
-    end
-  end
-
-  # Spec helper methods
-
-  def stub_the_compiler(options = {:stub_methods => [:store_content]})
-    # Build a resource catalog suitable for specifying the behavior of the
-    # static compiler.
-    compiler = mock('indirection terminus compiler')
-    compiler.stubs(:find).returns(build_catalog(options))
-    subject.stubs(:compiler).returns(compiler)
-    # Mock the store content method to prevent copying the contents to the
-    # file bucket.
-    (options[:stub_methods] || []).each do |mthd|
-      subject.stubs(mthd)
-    end
-  end
-
-  def build_catalog(options = {})
-    options = options.dup
-    options[:source] ||= 'puppet:///modules/mymodule/config_file.txt'
-    options[:request] ||= request
-
-    # Build a catalog suitable for the static compiler to operate on
-    catalog = Puppet::Resource::Catalog.new("#{options[:request].key}")
-
-    # Mock out the fileserver, otherwise converting the catalog to a
-    fake_fileserver_metadata = fileserver_metadata(options)
-
-    # Stub the call to the FileServer metadata API so we don't have to have
-    # a real fileserver initialized for testing.
-    Puppet::FileServing::Metadata.
-      indirection.stubs(:find).
-      with(options[:source].sub('puppet:///',''), :links => :manage).
-      returns(fake_fileserver_metadata)
-
-    # I want a resource that all the file resources require and another
-    # that requires them.
-    resources = Array.new
-    resources << Puppet::Resource.new("notify", "alpha")
-    resources << Puppet::Resource.new("notify", "omega")
-
-    # Create some File resources with source parameters.
-    1.upto(@num_file_resources) do |idx|
-      parameters = {
-        :ensure  => 'file',
-        :source  => options[:source],
-        :require => "Notify[alpha]",
-        :before  => "Notify[omega]"
-      }
-      # The static compiler does not operate on a RAL catalog, so we're
-      # using Puppet::Resource to produce a resource catalog.
-      agnostic_path = File.expand_path("/tmp/file_#{idx}.txt") # Windows Friendly
-      rsrc = Puppet::Resource.new("file", agnostic_path, :parameters => parameters)
-      rsrc.file = 'site.pp'
-      rsrc.line = idx
-      resources << rsrc
-    end
-
-    resources.each do |rsrc|
-      catalog.add_resource(rsrc)
-    end
-
-    # Return the resource catalog
-    catalog
-  end
-
-  def fileserver_metadata(options = {})
-    yaml = <<EOFILESERVERMETADATA
---- !ruby/object:Puppet::FileServing::Metadata
-  checksum: "{md5}361fadf1c712e812d198c4cab5712a79"
-  checksum_type: md5
-  destination: 
-  expiration: #{Time.now + 1800}
-  ftype: file
-  group: 0
-  links: !ruby/sym manage
-  mode: 420
-  owner: 0
-  path: #{File.expand_path('/etc/puppet/modules/mymodule/files/config_file.txt')}
-  source: #{options[:source]}
-  stat_method: !ruby/sym lstat
-EOFILESERVERMETADATA
-    # Return a deserialized metadata object suitable for returning from a stub.
-    YAML.load(yaml)
-  end
-end
-

data/spec/unit/indirector/certificate/disabled_ca_spec.rb

@@ -1,33 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'puppet/indirector/certificate/disabled_ca'
-
-describe Puppet::SSL::Certificate::DisabledCa do
-  def request(type, remote)
-    r = Puppet::Indirector::Request.new(:certificate, type, "foo.com", nil)
-    if remote
-      r.ip   = '10.0.0.1'
-      r.node = 'agent.example.com'
-    end
-    r
-  end
-
-  context "when not a CA" do
-    before :each do
-      Puppet[:ca] = false
-      Puppet::SSL::Host.ca_location = :none
-    end
-
-    [:find, :head, :search, :save, :destroy].each do |name|
-      it "should fail remote #{name} requests" do
-        expect { subject.send(name, request(name, true)) }.
-          to raise_error Puppet::Error, /is not a CA/
-      end
-
-      it "should forward local #{name} requests" do
-        Puppet::SSL::Certificate.indirection.terminus(:file).expects(name)
-        subject.send(name, request(name, false))
-      end
-    end
-  end
-end

data/spec/unit/indirector/certificate_request/disabled_ca_spec.rb

@@ -1,33 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'puppet/indirector/certificate_request/disabled_ca'
-
-describe Puppet::SSL::CertificateRequest::DisabledCa do
-  def request(type, remote)
-    r = Puppet::Indirector::Request.new(:certificate_request, type, "foo.com", nil)
-    if remote
-      r.ip   = '10.0.0.1'
-      r.node = 'agent.example.com'
-    end
-    r
-  end
-
-  context "when not a CA" do
-    before :each do
-      Puppet[:ca] = false
-      Puppet::SSL::Host.ca_location = :none
-    end
-
-    [:find, :head, :search, :save, :destroy].each do |name|
-      it "should fail remote #{name} requests" do
-        expect { subject.send(name, request(name, true)) }.
-          to raise_error Puppet::Error, /is not a CA/
-      end
-
-      it "should forward local #{name} requests" do
-        Puppet::SSL::CertificateRequest.indirection.terminus(:file).expects(name)
-        subject.send(name, request(name, false))
-      end
-    end
-  end
-end

data/spec/unit/indirector/certificate_revocation_list/disabled_ca_spec.rb

@@ -1,33 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'puppet/indirector/certificate_revocation_list/disabled_ca'
-
-describe Puppet::SSL::CertificateRevocationList::DisabledCa do
-  def request(type, remote)
-    r = Puppet::Indirector::Request.new(:certificate_revocation_list, type, "foo.com", nil)
-    if remote
-      r.ip   = '10.0.0.1'
-      r.node = 'agent.example.com'
-    end
-    r
-  end
-
-  context "when not a CA" do
-    before :each do
-      Puppet[:ca] = false
-      Puppet::SSL::Host.ca_location = :none
-    end
-
-    [:find, :head, :search, :save, :destroy].each do |name|
-      it "should fail remote #{name} requests" do
-        expect { subject.send(name, request(name, true)) }.
-          to raise_error Puppet::Error, /is not a CA/
-      end
-
-      it "should forward local #{name} requests" do
-        Puppet::SSL::CertificateRevocationList.indirection.terminus(:file).expects(name)
-        subject.send(name, request(name, false))
-      end
-    end
-  end
-end

data/spec/unit/indirector/inventory/yaml_spec.rb

@@ -1,220 +0,0 @@
-#!/usr/bin/env rspec
-require 'spec_helper'
-
-require 'puppet/node/inventory'
-require 'puppet/indirector/inventory/yaml'
-require 'puppet/indirector/request'
-
-describe Puppet::Node::Inventory::Yaml do
-  def assert_search_matches(matching, nonmatching, query)
-    request = Puppet::Indirector::Request.new(:inventory, :search, nil, query)
-
-    Dir.stubs(:glob).returns(matching.keys + nonmatching.keys)
-    [matching, nonmatching].each do |examples|
-      examples.each do |key, value|
-        YAML.stubs(:load_file).with(key).returns value
-      end
-    end
-    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
-    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')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
-        "/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'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
-      },
-      {'facts.architecture' => 'i386', 'facts.processor_count' => '4'}
-    )
-  end
-
-  it "should return empty array when no nodes match the search query options" do
-    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'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
-      },
-      {'facts.processor_count.lt' => '4', 'facts.processor_count.gt' => '4'}
-    )
-  end
-
-
-  it "should return node names that match the search query options with the greater than operator" do
-    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')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '3'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                       ),
-      },
-      {'facts.processor_count.gt' => '4'}
-    )
-  end
-
-  it "should return node names that match the search query options with the less than operator" do
-    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')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '50' ),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '100'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                         ),
-      },
-      {'facts.processor_count.lt' => '50'}
-    )
-  end
-
-  it "should return node names that match the search query options with the less than or equal to operator" do
-    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')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '100' ),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5000'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                          ),
-      },
-      {'facts.processor_count.le' => '50'}
-    )
-  end
-
-  it "should return node names that match the search query options with the greater than or equal to operator" do
-    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')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '40'),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '9' ),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                        ),
-      },
-      {'facts.processor_count.ge' => '50'}
-    )
-  end
-
-  it "should return node names that match the search query options with the not equal operator" do
-    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')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "i386"                           ),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                     ),
-      },
-      {'facts.architecture.ne' => 'i386'}
-    )
-  end
-
-  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