puppet 6.18.0-x86-mingw32 → 6.19.0-x86-mingw32

data/spec/unit/http/session_spec.rb

@@ -26,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
 
@@ -67,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
@@ -167,16 +156,15 @@ describe Puppet::HTTP::Session do
       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)
+      expect_any_instance_of(Puppet::HTTP::Resolver::Settings).to receive(:resolve).never
       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 {
         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

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/rest_spec.rb

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

data/spec/unit/indirector/json_spec.rb

@@ -11,24 +11,24 @@ describe Puppet::Indirector::JSON do
 
   context "#path" do
     before :each do
-      Puppet[:server_datadir] = '/sample/datadir/master'
+      Puppet[:server_datadir] = '/sample/datadir/server'
       Puppet[:client_datadir] = '/sample/datadir/client'
     end
 
-    it "uses the :server_datadir setting if this is the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+    it "uses the :server_datadir setting if this is the server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.json')
       expect(subject.path('testing')).to eq(expected)
     end
 
-    it "uses the :client_datadir setting if this is not the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    it "uses the :client_datadir setting if this is not the server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(false)
       expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.json')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "overrides the default extension with a supplied value" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-json')
       expect(subject.path('testing', '.not-json')).to eq(expected)
     end
@@ -50,7 +50,7 @@ describe Puppet::Indirector::JSON do
 
   context "handling requests" do
     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'))
     end
@@ -158,7 +158,7 @@ describe Puppet::Indirector::JSON do
 
   context "#search" do
     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'))
     end

data/spec/unit/indirector/msgpack_spec.rb

@@ -11,24 +11,24 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
   context "#path" do
     before :each do
-      Puppet[:server_datadir] = '/sample/datadir/master'
+      Puppet[:server_datadir] = '/sample/datadir/server'
       Puppet[:client_datadir] = '/sample/datadir/client'
     end
 
-    it "uses the :server_datadir setting if this is the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+    it "uses the :server_datadir setting if this is the server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.msgpack')
       expect(subject.path('testing')).to eq(expected)
     end
 
-    it "uses the :client_datadir setting if this is not the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    it "uses the :client_datadir setting if this is not the server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(false)
       expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.msgpack')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "overrides the default extension with a supplied value" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-msgpack')
       expect(subject.path('testing', '.not-msgpack')).to eq(expected)
     end
@@ -50,7 +50,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
   context "handling requests" do
     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('msgpackdir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end
@@ -158,7 +158,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
   context "#search" do
     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('msgpackdir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end

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

@@ -10,7 +10,7 @@ describe Puppet::Node::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/request_spec.rb

@@ -126,8 +126,8 @@ describe Puppet::Indirector::Request do
         expect(Puppet::Indirector::Request.new(:ind, :method, "http://host:543/", nil).port).to eq(543)
       end
 
-      it "should default to the masterport if the URI scheme is 'puppet'" do
-        Puppet[:masterport] = "321"
+      it "should default to the serverport if the URI scheme is 'puppet'" do
+        Puppet[:serverport] = "321"
         expect(Puppet::Indirector::Request.new(:ind, :method, "puppet://host/", nil).port).to eq(321)
       end
 
@@ -534,7 +534,7 @@ describe Puppet::Indirector::Request do
           expect(request.server).to be_nil
           expect(request.port).to be_nil
           expect(Puppet.settings[:server]).not_to be_nil
-          expect(Puppet.settings[:masterport]).not_to be_nil
+          expect(Puppet.settings[:serverport]).not_to be_nil
         end
       end
     end
@@ -552,7 +552,7 @@ describe Puppet::Indirector::Request do
       req = Puppet::Indirector::Request.new('node', 'find', 'localhost', nil)
       req.do_request() do |request|
         expect(request.server).to eq(Puppet.settings[:server])
-        expect(request.port).to eq(Puppet.settings[:masterport])
+        expect(request.port).to eq(Puppet.settings[:serverport])
       end
     end
   end

data/spec/unit/indirector/rest_spec.rb

@@ -249,7 +249,7 @@ describe Puppet::Indirector::REST do
 
   it "should default to :port for the port setting" do
     expect(terminus_class).to receive(:port_setting).and_return(nil)
-    Puppet[:masterport] = "543"
+    Puppet[:serverport] = "543"
     expect(terminus_class.port).to eq(543)
   end
 

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

@@ -9,7 +9,7 @@ describe Puppet::Indirector::Status::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/yaml_spec.rb

@@ -38,30 +38,30 @@ describe Puppet::Indirector::Yaml do
 
   before :each do
     Puppet[:clientyamldir] = dir
-    allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    allow(Puppet.run_mode).to receive(:server?).and_return(false)
   end
 
   describe "when choosing file location" do
-    it "should use the server_datadir if the run_mode is master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+    it "should use the server_datadir if the run_mode is server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(terminus.path(:me)).to match(/^#{serverdir}/)
     end
 
-    it "should use the client yamldir if the run_mode is not master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(false)
+    it "should use the client yamldir if the run_mode is not server" do
+      allow(Puppet.run_mode).to receive(:server?).and_return(false)
       Puppet[:clientyamldir] = clientdir
       expect(terminus.path(:me)).to match(/^#{clientdir}/)
     end
 
     it "should use the extension if one is specified" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(terminus.path(:me,'.farfignewton')).to match(%r{\.farfignewton$})
     end
 
     it "should assume an extension of .yaml if none is specified" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      allow(Puppet.run_mode).to receive(:server?).and_return(true)
       Puppet[:yamldir] = serverdir
       expect(terminus.path(:me)).to match(%r{\.yaml$})
     end

data/spec/unit/network/http/api/master/v3/environments_spec.rb

@@ -7,13 +7,14 @@ require 'matchers/json'
 describe Puppet::Network::HTTP::API::Master::V3::Environments do
   include JSONMatchers
 
-  it "responds with all of the available environments" do
-    environment = Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests')
-    loader = Puppet::Environments::Static.new(environment)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
+  let(:environment) { Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests') }
+  let(:loader) { Puppet::Environments::Static.new(environment) }
+  let(:handler) { Puppet::Network::HTTP::API::Master::V3::Environments.new(loader) }
+  let(:request) { Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }) }
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+  it "responds with all of the available environments" do
+    handler.call(request, response)
 
     expect(response.code).to eq(200)
     expect(response.type).to eq("application/json")
@@ -33,29 +34,17 @@ describe Puppet::Network::HTTP::API::Master::V3::Environments do
   end
 
   it "the response conforms to the environments schema for unlimited timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(Float::INFINITY)
-    environment = Puppet::Node::Environment.create(:production, [])
-    env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
+    Puppet[:environment_timeout] = 'unlimited'
 
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end
 
   it "the response conforms to the environments schema for integer timeout" do
-    conf_stub = double('conf_stub')
-    expect(conf_stub).to receive(:environment_timeout).and_return(1)
-    environment = Puppet::Node::Environment.create(:production, [])
-    env_loader = Puppet::Environments::Static.new(environment)
-    expect(env_loader).to receive(:get_conf).with(:production).and_return(conf_stub)
-    handler = Puppet::Network::HTTP::API::Master::V3::Environments.new(env_loader)
-    response = Puppet::Network::HTTP::MemoryResponse.new
-
-    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+    Puppet[:environment_timeout] = 1
+
+    handler.call(request, response)
 
     expect(response.body).to validate_against('api/schemas/environments.json')
   end

data/spec/unit/provider/exec_spec.rb

@@ -49,9 +49,10 @@ describe Puppet::Provider::Exec do
         # we can't reference that in our manifest. Windows PATHs can contain
         # double quotes and trailing backslashes, which confuse HEREDOC
         # interpolation below. So sanitize it:
-        ENV['PATH'].split(File::PATH_SEPARATOR).map do |dir|
-          dir.gsub(/"/, '\"').gsub(/\\$/, '')
-        end.join(File::PATH_SEPARATOR)
+        ENV['PATH'].split(File::PATH_SEPARATOR)
+                   .map { |dir| dir.gsub(/"/, '\"').gsub(/\\$/, '') }
+                   .map { |dir| Pathname.new(dir).cleanpath.to_s }
+                   .join(File::PATH_SEPARATOR)
       else
         ENV['PATH']
       end

data/spec/unit/provider/package/dpkg_spec.rb

@@ -32,7 +32,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(bash_installed_io)
 
       installed = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(installed)
+      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg).and_return(installed)
 
       expect(described_class.instances).to eq([installed])
     end
@@ -41,9 +41,9 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       expect(Puppet::Util::Execution).to receive(:execpipe).with(execpipe_args).and_yield(all_installed_io)
 
       bash = double('bash')
-      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg).and_return(bash)
+      expect(described_class).to receive(:new).with(:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg).and_return(bash)
       vim = double('vim')
-      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :status => "installed", :provider => :dpkg).and_return(vim)
+      expect(described_class).to receive(:new).with(:ensure => "2:7.3.547-6ubuntu5", :error => "ok", :desired => "install", :name => "vim", :mark => :none, :status => "installed", :provider => :dpkg).and_return(vim)
 
       expect(described_class.instances).to eq([bash, vim])
     end
@@ -107,7 +107,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
         it "returns a hash of the found package status for an installed package" do
           dpkg_query_execution_with_multiple_args_returns(query_output, args_with_provides,virtual_packages_query_args)
           dpkg_query_execution_with_multiple_args_returns(dpkg_query_result, args, query_args)
-          expect(provider.query).to eq(:ensure => "2.7.13", :error => "ok", :desired => "install", :name => "python", :status => "installed", :provider => :dpkg)
+          expect(provider.query).to eq(:ensure => "2.7.13", :error => "ok", :desired => "install", :name => "python", :mark => :none, :status => "installed", :provider => :dpkg)
         end
 
         it "considers the package absent if the dpkg-query result cannot be interpreted" do
@@ -160,6 +160,20 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
           expect(provider.query[:mark]).to eq(:hold)
         end
 
+        it "considers the package held if its state is 'hold'" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("install","hold"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("install","hold"), args, query_args)
+          expect(provider.query[:ensure]).to eq("2.7.13")
+          expect(provider.query[:mark]).to eq(:hold)
+        end
+
+        it "considers mark status to be none if package is not held" do
+          dpkg_query_execution_with_multiple_args_returns(query_output.gsub("install","ok"),args_with_provides,virtual_packages_query_args)
+          dpkg_query_execution_with_multiple_args_returns(dpkg_query_result.gsub("install","ok"), args, query_args)
+          expect(provider.query[:ensure]).to eq("2.7.13")
+          expect(provider.query[:mark]).to eq(:none)
+        end
+
         context "regex check for query search" do
           let(:resource_name) { 'python-email' }
           let(:resource) { instance_double('Puppet::Type::Package') }
@@ -168,10 +182,10 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
             allow(resource).to receive(:[]=)
           end
 
-          it "checks if virtual package regex for query is correctand phisical package is installed" do
+          it "checks if virtual package regex for query is correct and physical package is installed" do
             dpkg_query_execution_with_multiple_args_returns(query_output,args_with_provides,virtual_packages_query_args)
             dpkg_query_execution_with_multiple_args_returns(dpkg_query_result, args, query_args)
-            expect(provider.query).to match({:desired=>"install", :ensure=>"2.7.13", :error=>"ok", :name=>"python", :provider=>:dpkg, :status=>"installed"})
+            expect(provider.query).to match({:desired => "install", :ensure => "2.7.13", :error => "ok", :name => "python", :mark => :none, :provider => :dpkg, :status => "installed"})
           end
 
           context "regex check with no partial matching" do
@@ -208,7 +222,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       it "returns a hash of the found package status for an installed package" do
         dpkg_query_execution_returns(bash_installed_output)
 
-        expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :status => "installed", :provider => :dpkg})
+        expect(provider.query).to eq({:ensure => "4.2-5ubuntu3", :error => "ok", :desired => "install", :name => "bash", :mark => :none, :status => "installed", :provider => :dpkg})
       end
 
       it "considers the package absent if the dpkg-query result cannot be interpreted" do
@@ -271,6 +285,7 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
             :error => 'ok',
             :status => 'status',
             :name => resource_name,
+            :mark => :none,
             :ensure => 'ensure',
             :provider => :dpkg,
           }

data/spec/unit/provider/package/openbsd_spec.rb

@@ -46,6 +46,8 @@ describe Puppet::Type.type(:package).provider(:openbsd) do
     allow(described_class).to receive(:command).with(:pkginfo).and_return('/bin/pkg_info')
     allow(described_class).to receive(:command).with(:pkgadd).and_return('/bin/pkg_add')
     allow(described_class).to receive(:command).with(:pkgdelete).and_return('/bin/pkg_delete')
+
+    allow(Puppet::FileSystem).to receive(:exist?)
   end
 
   context "#instances" do

data/spec/unit/provider/package/pip2_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Puppet::Type.type(:package).provider(:pip2) do
+
+  it { is_expected.to be_installable }
+  it { is_expected.to be_uninstallable }
+  it { is_expected.to be_upgradeable }
+  it { is_expected.to be_versionable }
+  it { is_expected.to be_install_options }
+  it { is_expected.to be_targetable }
+
+  it "should inherit most things from pip provider" do
+    expect(described_class < Puppet::Type.type(:package).provider(:pip))
+  end
+
+  it "should use pip2 command" do
+    expect(described_class.cmd).to eq(["pip2"])
+  end
+
+  context 'calculated specificity' do
+    context 'when is not defaultfor' do
+      subject { described_class.specificity }
+      it { is_expected.to eql 1 }
+    end
+
+    context 'when is defaultfor' do
+      let(:os) {  Facter.value(:operatingsystem) }
+      subject do
+        described_class.defaultfor(operatingsystem: os)
+        described_class.specificity
+      end
+      it { is_expected.to be > 100 }
+    end
+  end
+
+end