puppet 6.17.0-x64-mingw32 → 7.1.0-x64-mingw32

data/spec/unit/http/service_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 require 'puppet/file_serving'
 require 'puppet/file_serving/content'
@@ -127,7 +126,6 @@ describe Puppet::HTTP::Service do
       Puppet::Node::Facts,
       Puppet::Transaction::Report,
       Puppet::FileServing::Metadata,
-      Puppet::Status
     ].each do |model|
       expect(service.mime_types(model)).to eq(mimes)
     end
@@ -138,7 +136,7 @@ describe Puppet::HTTP::Service do
     catalog_mimes = if Puppet.features.msgpack?
                       %w[application/vnd.puppet.rich+json application/json application/vnd.puppet.rich+msgpack application/x-msgpack text/pson]
                     else
-                      %w[application/vnd.puppet.rich+json application/json application/vnd.puppet.rich+msgpack text/pson]
+                      %w[application/vnd.puppet.rich+json application/json text/pson]
                     end
     expect(service.mime_types(Puppet::Resource::Catalog)).to eq(catalog_mimes)
   end

data/spec/unit/http/session_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'webmock/rspec'
 require 'puppet/http'
 
 describe Puppet::HTTP::Session do
@@ -27,9 +26,9 @@ describe Puppet::HTTP::Session do
       @count = 0
     end
 
-    def resolve(session, name, ssl_context: nil, error_handler: nil)
+    def resolve(session, name, ssl_context: nil, canceled_handler: nil)
       @count += 1
-      return @service if check_connection?(session, @service, ssl_context: ssl_context, error_handler: error_handler)
+      return @service if check_connection?(session, @service, ssl_context: ssl_context)
     end
   end
 
@@ -68,19 +67,8 @@ describe Puppet::HTTP::Session do
         session.route_to(:ca)
       }.to raise_error(Puppet::HTTP::RouteError, 'No more routes to ca')
 
-      expect(@logs).to include(an_object_having_attributes(level: :err, message: "whoops1"),
-                               an_object_having_attributes(level: :err, message: "whoops2"))
-    end
-
-    it 'logs routing failures as debug until routing succeeds' do
-      Puppet[:log_level] = 'debug'
-
-      resolvers = [DummyResolver.new(bad_service), DummyResolver.new(good_service)]
-      session = described_class.new(client, resolvers)
-      session.route_to(:ca)
-
-      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Connection to #{uri} failed, trying next route: whoops"))
-      expect(@logs).to_not include(an_object_having_attributes(level: :err))
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: "Connection to #{uri} failed, trying next route: whoops1"),
+                               an_object_having_attributes(level: :err, message: "Connection to #{uri} failed, trying next route: whoops2"))
     end
 
     it 'accepts an ssl context to use when connecting' do
@@ -139,7 +127,7 @@ describe Puppet::HTTP::Session do
       Puppet[:server_list] = 'foo.example.com,bar.example.com,baz.example.com'
       Puppet[:ca_server] = 'caserver.example.com'
 
-      allow_any_instance_of(Puppet::Network::Resolver).to receive(:each_srv_record).and_yield('mars.example.srv', 8140)
+      allow_any_instance_of(Puppet::HTTP::DNS).to receive(:each_srv_record).and_yield('mars.example.srv', 8140)
       service = session.route_to(:ca)
 
       expect(service.url).to eq(URI("https://mars.example.srv:8140/puppet-ca/v1"))
@@ -159,25 +147,24 @@ describe Puppet::HTTP::Session do
       Puppet[:use_srv_records] = true
       Puppet[:server_list] = 'foo.example.com,bar.example.com,baz.example.com'
 
-      allow_any_instance_of(Puppet::Network::Resolver).to receive(:each_srv_record)
-      stub_request(:get, "https://foo.example.com:8140/status/v1/simple/master").to_return(status: 500)
-      stub_request(:get, "https://bar.example.com:8140/status/v1/simple/master").to_return(status: 200)
+      allow_any_instance_of(Puppet::HTTP::DNS).to receive(:each_srv_record)
+      stub_request(:get, "https://foo.example.com:8140/status/v1/simple/server").to_return(status: 500)
+      stub_request(:get, "https://bar.example.com:8140/status/v1/simple/server").to_return(status: 200)
 
       service = session.route_to(:ca)
 
       expect(service.url).to eq(URI("https://bar.example.com:8140/puppet-ca/v1"))
     end
 
-    it "fails if server_list doesn't return anything valid" do
-      Puppet[:server_list] = 'foo.example.com,bar.example.com'
+    it "does not fallback from server_list to the settings resolver when server_list is exhausted" do
+      Puppet[:server_list] = 'foo.example.com'
 
-      allow_any_instance_of(Puppet::Network::Resolver).to receive(:each_srv_record)
-      stub_request(:get, "https://foo.example.com:8140/status/v1/simple/master").to_return(status: 500)
-      stub_request(:get, "https://bar.example.com:8140/status/v1/simple/master").to_return(status: 500)
+      expect_any_instance_of(Puppet::HTTP::Resolver::Settings).to receive(:resolve).never
+      stub_request(:get, "https://foo.example.com:8140/status/v1/simple/server").to_return(status: 500)
 
       expect {
         session.route_to(:ca)
-      }.to raise_error(Puppet::Error, "Could not select a functional puppet master from server_list: 'foo.example.com,bar.example.com'")
+      }.to raise_error(Puppet::HTTP::RouteError, "No more routes to ca")
     end
 
     it "raises when there are no more routes" do
@@ -192,7 +179,7 @@ describe Puppet::HTTP::Session do
     Puppet::HTTP::Service::SERVICE_NAMES.each do |name|
       it "resolves #{name} using server_list" do
         Puppet[:server_list] = 'apple.example.com'
-        req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+        req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/server").to_return(status: 200)
 
         session.route_to(name)
 
@@ -214,7 +201,7 @@ describe Puppet::HTTP::Session do
 
     it 'resolves once for all services in a session' do
       Puppet[:server_list] = 'apple.example.com'
-      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/server").to_return(status: 200)
 
       Puppet::HTTP::Service::SERVICE_NAMES.each do |name|
         session.route_to(name)
@@ -225,7 +212,7 @@ describe Puppet::HTTP::Session do
 
     it 'resolves server_list for each new session' do
       Puppet[:server_list] = 'apple.example.com'
-      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/master").to_return(status: 200)
+      req = stub_request(:get, "https://apple.example.com:8140/status/v1/simple/server").to_return(status: 200)
 
       client.create_session.route_to(:puppet)
       client.create_session.route_to(:puppet)
@@ -235,6 +222,8 @@ describe Puppet::HTTP::Session do
   end
 
   context 'when retrieving capabilities' do
+    let(:response) { Puppet::HTTP::Response.new(uri, 200, 'OK') }
+
     let(:session) do
       resolver = DummyResolver.new(good_service)
       described_class.new(client, [resolver])
@@ -255,7 +244,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "supports locales if the cached service's version is 5.3.4 or greater" do
-        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.3.4'}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return('5.3.4')
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -264,7 +253,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "does not support locales if the cached service's version is 5.3.3" do
-        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.3.3'}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return('5.3.3')
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -273,7 +262,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "does not support locales if the cached service's version is missing" do
-        response = Puppet::HTTP::Response.new({}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return(nil)
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -290,7 +279,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "supports json if the cached service's version is 5 or greater" do
-        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '5.5.12'}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return('5.5.12')
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -299,7 +288,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "does not support json if the cached service's version is less than 5.0" do
-        response = Puppet::HTTP::Response.new({'X-Puppet-Version' => '4.10.1'}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return('4.10.1')
 
         session.route_to(:puppet)
         session.process_response(response)
@@ -308,7 +297,7 @@ describe Puppet::HTTP::Session do
       end
 
       it "supports json if the cached service's version is missing" do
-        response = Puppet::HTTP::Response.new({}, uri)
+        allow(response).to receive(:[]).with('X-Puppet-Version').and_return(nil)
 
         session.route_to(:puppet)
         session.process_response(response)

data/spec/unit/{network/http → http}/site_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-require 'puppet/network/http'
+require 'puppet/http'
 
-describe Puppet::Network::HTTP::Site do
+describe Puppet::HTTP::Site do
   let(:scheme)      { 'https' }
   let(:host)        { 'rubygems.org' }
   let(:port)        { 443 }
 
   def create_site(scheme, host, port)
-    Puppet::Network::HTTP::Site.new(scheme, host, port)
+    described_class.new(scheme, host, port)
   end
 
   it 'accepts scheme, host, and port' do

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

@@ -24,7 +24,7 @@ describe Puppet::Resource::Catalog::Json do
     end
 
     before :each do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:server_datadir] = tmpdir('jsondir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
       Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))

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

@@ -10,7 +10,7 @@ describe Puppet::Resource::Catalog::Rest do
 
   before :each do
     Puppet[:server] = 'compiler.example.com'
-    Puppet[:masterport] = 8140
+    Puppet[:serverport] = 8140
 
     described_class.indirection.terminus_class = :rest
   end

data/spec/unit/indirector/facts/facter_spec.rb

@@ -29,6 +29,7 @@ describe Puppet::Node::Facts::Facter do
     @request = double('request', :key => @name)
     @environment = double('environment')
     allow(@request).to receive(:environment).and_return(@environment)
+    allow(@request).to receive(:options).and_return({})
     allow(@request.environment).to receive(:modules).and_return([])
     allow(@request.environment).to receive(:modulepath).and_return([])
   end
@@ -105,6 +106,7 @@ describe Puppet::Node::Facts::Facter do
       expect(FileTest).to receive(:directory?).with(factpath1).and_return(true)
       expect(FileTest).to receive(:directory?).with(factpath2).and_return(true)
       allow(@request.environment).to receive(:modulepath).and_return([modulepath])
+      allow(@request).to receive(:options).and_return({})
       expect(Dir).to receive(:glob).with("#{modulepath}/*/lib/facter").and_return([modulelibfacter])
       expect(Dir).to receive(:glob).with("#{modulepath}/*/plugins/facter").and_return([modulepluginsfacter])
 
@@ -150,4 +152,99 @@ describe Puppet::Node::Facts::Facter do
       Puppet::Node::Facts::Facter.setup_external_search_paths @request
     end
   end
+
+  describe 'when :resolve_options is true' do
+    let(:options) { { resolve_options: true, user_query: ["os", "timezone"], show_legacy: true } }
+    let(:facts) { Puppet::Node::Facts.new("foo") }
+
+    before :each do
+      allow(@request).to receive(:options).and_return(options)
+      allow(Puppet::Node::Facts).to receive(:new).and_return(facts)
+      allow(Facter).to receive(:respond_to?).and_return(false)
+      allow(Facter).to receive(:respond_to?).with(:resolve).and_return(true)
+      allow(facts).to receive(:add_local_facts)
+    end
+
+    it 'should call Facter.resolve method' do
+      expect(Facter).to receive(:resolve).with("os timezone --show-legacy")
+      @facter.find(@request)
+    end
+
+    it 'should NOT add local facts' do
+      expect(facts).not_to receive(:add_local_facts)
+
+      @facter.find(@request)
+    end
+
+    describe 'when Facter version is lower than 4.0.40' do
+      before :each do
+        allow(Facter).to receive(:respond_to?).and_return(false)
+        allow(Facter).to receive(:respond_to?).with(:resolve).and_return(false)
+      end
+
+      it 'raises an error' do
+        expect { @facter.find(@request) }.to raise_error(Puppet::Error, "puppet facts show requires version 4.0.40 or greater of Facter.")
+      end
+    end
+
+    describe 'when setting up external search paths' do
+      let(:options) { { resolve_options: true, user_query: ["os", "timezone"], external_dir: 'some/dir' } }
+      let(:pluginfactdest) { File.expand_path 'plugin/dest' }
+      let(:modulepath) { File.expand_path 'module/foo' }
+      let(:modulefactsd) { File.expand_path 'module/foo/facts.d'  }
+
+      before :each do
+        expect(FileTest).to receive(:directory?).with(pluginfactdest).and_return(true)
+        mod = Puppet::Module.new('foo', modulepath, @request.environment)
+        allow(@request.environment).to receive(:modules).and_return([mod])
+        Puppet[:pluginfactdest] = pluginfactdest
+      end
+
+      it 'should skip files' do
+        expect(File).to receive(:directory?).with(modulefactsd).and_return(false)
+        expect(Facter).to receive(:search_external).with([pluginfactdest, options[:external_dir]])
+        Puppet::Node::Facts::Facter.setup_external_search_paths @request
+      end
+
+      it 'should add directories' do
+        expect(File).to receive(:directory?).with(modulefactsd).and_return(true)
+        expect(Facter).to receive(:search_external).with([modulefactsd, pluginfactdest, options[:external_dir]])
+        Puppet::Node::Facts::Facter.setup_external_search_paths @request
+      end
+    end
+
+    describe 'when setting up search paths' do
+      let(:factpath1) { File.expand_path 'one' }
+      let(:factpath2) { File.expand_path 'two' }
+      let(:factpath) { [factpath1, factpath2].join(File::PATH_SEPARATOR) }
+      let(:modulepath) { File.expand_path 'module/foo' }
+      let(:modulelibfacter) { File.expand_path 'module/foo/lib/facter' }
+      let(:modulepluginsfacter) { File.expand_path 'module/foo/plugins/facter' }
+      let(:options) { { resolve_options: true, custom_dir: 'some/dir' } }
+
+      before :each do
+        expect(FileTest).to receive(:directory?).with(factpath1).and_return(true)
+        expect(FileTest).to receive(:directory?).with(factpath2).and_return(true)
+        allow(@request.environment).to receive(:modulepath).and_return([modulepath])
+        expect(Dir).to receive(:glob).with("#{modulepath}/*/lib/facter").and_return([modulelibfacter])
+        expect(Dir).to receive(:glob).with("#{modulepath}/*/plugins/facter").and_return([modulepluginsfacter])
+
+        Puppet[:factpath] = factpath
+      end
+
+      it 'should skip files' do
+        expect(FileTest).to receive(:directory?).with(modulelibfacter).and_return(false)
+        expect(FileTest).to receive(:directory?).with(modulepluginsfacter).and_return(false)
+        expect(Facter).to receive(:search).with(factpath1, factpath2, options[:custom_dir])
+        Puppet::Node::Facts::Facter.setup_search_paths @request
+      end
+
+      it 'should add directories' do
+        expect(FileTest).to receive(:directory?).with(modulelibfacter).and_return(true)
+        expect(FileTest).to receive(:directory?).with(modulepluginsfacter).and_return(false)
+        expect(Facter).to receive(:search).with(modulelibfacter, factpath1, factpath2, options[:custom_dir])
+        Puppet::Node::Facts::Facter.setup_search_paths @request
+      end
+    end
+  end
 end

data/spec/unit/indirector/facts/json_spec.rb

@@ -0,0 +1,255 @@
+require 'spec_helper'
+
+require 'puppet/node/facts'
+require 'puppet/indirector/facts/json'
+
+def dir_containing_json_facts(hash)
+  jsondir = tmpdir('json_facts')
+
+  Puppet[:client_datadir] = jsondir
+  dir = File.join(jsondir, 'facts')
+  Dir.mkdir(dir)
+  hash.each_pair do |file, facts|
+    File.open(File.join(dir, file), 'wb') do |f|
+      f.write(JSON.dump(facts))
+    end
+  end
+end
+
+describe Puppet::Node::Facts::Json do
+  include PuppetSpec::Files
+
+  it "should be a subclass of the Json terminus" do
+    expect(Puppet::Node::Facts::Json.superclass).to equal(Puppet::Indirector::JSON)
+  end
+
+  it "should have documentation" do
+    expect(Puppet::Node::Facts::Json.doc).not_to be_nil
+    expect(Puppet::Node::Facts::Json.doc).not_to be_empty
+  end
+
+  it "should be registered with the facts indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:facts)
+    expect(Puppet::Node::Facts::Json.indirection).to equal(indirection)
+  end
+
+  it "should have its name set to :json" do
+    expect(Puppet::Node::Facts::Json.name).to eq(:json)
+  end
+
+  it "should allow network requests" do
+    # Doesn't allow json as a network format, but allows `puppet facts upload`
+    # to update the JSON cache on a master.
+    expect(Puppet::Node::Facts::Json.new.allow_remote_requests?).to be(true)
+  end
+
+  describe "#search" do
+    def assert_search_matches(matching, nonmatching, query)
+      request = Puppet::Indirector::Request.new(:inventory, :search, nil, nil, query)
+
+      dir_containing_json_facts(matching.merge(nonmatching))
+
+      results = Puppet::Node::Facts::Json.new.search(request)
+      expect(results).to match_array(matching.values.map {|facts| facts.name})
+    end
+
+    it "should return node names that match the search query options" do
+      assert_search_matches({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386", 'processor_count' => '4'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+          "nonmatching1.json" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+          "nonmatching3.json" => 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({}, {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '10'),
+          "nonmatching1.json" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+          "nonmatching3.json" => 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({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '3'),
+          "nonmatching3.json" => 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({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '50' ),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '100'),
+          "nonmatching3.json" => 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({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '100' ),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5000'),
+          "nonmatching3.json" => 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({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '100'),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '40'),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '9' ),
+          "nonmatching3.json" => 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({
+          'matching.json'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => 'arm'                           ),
+          'matching1.json' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
+        },
+        {
+          "nonmatching.json"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "i386"                           ),
+          "nonmatching2.json" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
+          "nonmatching3.json" => 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({
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        },
+        {
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-10-15.json' => 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({
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => 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({
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-15.json' => 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({
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => 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({
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => 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({
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => 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({
+          '2010-11-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '2010-11-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '2010-10-01.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '2010-10-10.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {
+          '2010-10-15.json' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {'meta.timestamp.ne' => '2010-10-15'}
+      )
+    end
+  end
+end