chef 14.15.6 → 15.0.293

data/spec/unit/knife/user_edit_spec.rb

@@ -32,24 +32,6 @@ describe Chef::Knife::UserEdit do
     knife.config[:disable_editing] = true
   end
 
-  # delete this once OSC11 support is gone
-  context "when the username field is not supported by the server" do
-    before do
-      allow(knife).to receive(:run_osc_11_user_edit).and_raise(SystemExit)
-      allow(Chef::UserV1).to receive(:load).and_return({ "username" => nil })
-    end
-
-    it "displays the osc warning" do
-      expect(knife.ui).to receive(:warn).with(knife.osc_11_warning)
-      expect { knife.run }.to raise_error(SystemExit)
-    end
-
-    it "forwards the command to knife osc_user edit" do
-      expect(knife).to receive(:run_osc_11_user_edit)
-      expect { knife.run }.to raise_error(SystemExit)
-    end
-  end
-
   it "loads and edits the user" do
     data = { "username" => "my_user" }
     allow(Chef::UserV1).to receive(:load).with("my_user").and_return(data)

data/spec/unit/knife/user_reregister_spec.rb

@@ -32,24 +32,6 @@ describe Chef::Knife::UserReregister do
     allow(user_mock).to receive(:username).and_return("a_user")
   end
 
-  # delete this once OSC11 support is gone
-  context "when the username field is not supported by the server" do
-    before do
-      allow(knife).to receive(:run_osc_11_user_reregister).and_raise(SystemExit)
-      allow(user_mock).to receive(:username).and_return(nil)
-    end
-
-    it "displays the osc warning" do
-      expect(knife.ui).to receive(:warn).with(knife.osc_11_warning)
-      expect { knife.run }.to raise_error(SystemExit)
-    end
-
-    it "forwards the command to knife osc_user edit" do
-      expect(knife).to receive(:run_osc_11_user_reregister)
-      expect { knife.run }.to raise_error(SystemExit)
-    end
-  end
-
   it "prints usage and exits when a user name is not provided" do
     knife.name_args = []
     expect(knife).to receive(:show_usage)

data/spec/unit/knife/user_show_spec.rb

@@ -31,25 +31,6 @@ describe Chef::Knife::UserShow do
     allow(knife.ui).to receive(:stdout).and_return(stdout)
   end
 
-  # delete this once OSC11 support is gone
-  context "when the username field is not supported by the server" do
-    before do
-      allow(knife).to receive(:run_osc_11_user_show).and_raise(SystemExit)
-      allow(Chef::UserV1).to receive(:load).with("my_user").and_return(user_mock)
-      allow(user_mock).to receive(:username).and_return(nil)
-    end
-
-    it "displays the osc warning" do
-      expect(knife.ui).to receive(:warn).with(knife.osc_11_warning)
-      expect { knife.run }.to raise_error(SystemExit)
-    end
-
-    it "forwards the command to knife osc_user edit" do
-      expect(knife).to receive(:run_osc_11_user_show)
-      expect { knife.run }.to raise_error(SystemExit)
-    end
-  end
-
   it "loads and displays the user" do
     expect(Chef::UserV1).to receive(:load).with("my_user").and_return(user_mock)
     expect(knife).to receive(:format_for_display).with(user_mock)

data/spec/unit/knife_spec.rb

@@ -35,9 +35,9 @@ describe Chef::Knife do
 
   let(:config_loader) do
     instance_double("WorkstationConfigLoader",
-      load: nil, no_config_found?: false,
-      config_location: config_location,
-      chef_config_dir: "/etc/chef")
+                    load: nil, no_config_found?: false,
+                    config_location: config_location,
+                    chef_config_dir: "/etc/chef")
   end
 
   before(:each) do
@@ -55,7 +55,7 @@ describe Chef::Knife do
     allow(knife.ui).to receive(:print)
     allow(Chef::Log).to receive(:init)
     allow(Chef::Log).to receive(:level)
-    %i{debug info warn error crit}.each do |level_sym|
+    [:debug, :info, :warn, :error, :crit].each do |level_sym|
       allow(Chef::Log).to receive(level_sym)
     end
     allow(Chef::Knife).to receive(:puts)
@@ -166,8 +166,7 @@ describe Chef::Knife do
         "X-Chef-Version" => Chef::VERSION,
         "Host" => "api.opscode.piab",
         "X-REMOTE-REQUEST-ID" => request_id,
-    }
-    end
+    } end
 
     let(:request_id) { "1234" }
 
@@ -206,7 +205,7 @@ describe Chef::Knife do
         KnifeSpecs.send :remove_const, :TestYourself
       end
       Kernel.load(File.join(CHEF_SPEC_DATA, "knife_subcommand", "test_yourself.rb"))
-      Chef::Knife.subcommands.each { |name, klass| Chef::Knife.subcommands.delete(name) unless klass.is_a?(Class) }
+      Chef::Knife.subcommands.each { |name, klass| Chef::Knife.subcommands.delete(name) unless klass.kind_of?(Class) }
     end
 
     it "confirms that the headers include X-Remote-Request-Id" do
@@ -221,7 +220,7 @@ describe Chef::Knife do
         KnifeSpecs.send :remove_const, :TestYourself
       end
       Kernel.load(File.join(CHEF_SPEC_DATA, "knife_subcommand", "test_yourself.rb"))
-      Chef::Knife.subcommands.each { |name, klass| Chef::Knife.subcommands.delete(name) unless klass.is_a?(Class) }
+      Chef::Knife.subcommands.each { |name, klass| Chef::Knife.subcommands.delete(name) unless klass.kind_of?(Class) }
     end
 
     it "merges the global knife CLI options" do
@@ -281,11 +280,36 @@ describe Chef::Knife do
       expect(other_deps_loaded).to be_truthy
     end
 
+    describe "working with unmerged configuration in #config_source" do
+      let(:command) { KnifeSpecs::TestYourself.new([]) }
+
+      before do
+        KnifeSpecs::TestYourself.option(:opt_with_default,
+                                        short: "-D VALUE",
+                                        default: "default-value")
+      end
+      # This supports a use case used by plugins, where the pattern
+      # seems to follow:
+      #   cmd = KnifeCommand.new
+      #   cmd.config[:config_key] = value
+      #   cmd.run
+      #
+      # This bypasses Knife::run and the `merge_configs` call it
+      # performs - config_source should break when that happens.
+      context "when config is fed in directly without a merge" do
+        it "retains the value but returns nil as a config source" do
+          command.config[:test1] = "value"
+          expect(command.config[:test1]).to eq "value"
+          expect(command.config_source(:test1)).to eq nil
+        end
+      end
+
+    end
     describe "merging configuration options" do
       before do
         KnifeSpecs::TestYourself.option(:opt_with_default,
-          short: "-D VALUE",
-          default: "default-value")
+                                        short: "-D VALUE",
+                                        default: "default-value")
       end
 
       it "sets the default log_location to STDERR for Chef::Log warnings" do
@@ -300,29 +324,32 @@ describe Chef::Knife do
         expect(Chef::Config[:log_level]).to eql(:warn)
       end
 
-      it "prefers the default value if no config or command line value is present" do
+      it "prefers the default value from option definition if no config or command line value is present and reports the source as default" do
         knife_command = KnifeSpecs::TestYourself.new([]) # empty argv
         knife_command.configure_chef
         expect(knife_command.config[:opt_with_default]).to eq("default-value")
+        expect(knife_command.config_source(:opt_with_default)).to eq(:cli_default)
       end
 
-      it "prefers a value in Chef::Config[:knife] to the default" do
+      it "prefers a value in Chef::Config[:knife] to the default and reports the source as config" do
         Chef::Config[:knife][:opt_with_default] = "from-knife-config"
         knife_command = KnifeSpecs::TestYourself.new([]) # empty argv
         knife_command.configure_chef
         expect(knife_command.config[:opt_with_default]).to eq("from-knife-config")
+        expect(knife_command.config_source(:opt_with_default)).to eq(:config)
       end
 
-      it "prefers a value from command line over Chef::Config and the default" do
-        Chef::Config[:knife][:opt_with_default] = "from-knife-config"
+      it "prefers a value from command line over Chef::Config and the default and reports the source as CLI" do
         knife_command = KnifeSpecs::TestYourself.new(["-D", "from-cli"])
         knife_command.configure_chef
         expect(knife_command.config[:opt_with_default]).to eq("from-cli")
+        expect(knife_command.config_source(:opt_with_default)).to eq(:cli)
       end
 
       it "merges `listen` config to Chef::Config" do
-        Chef::Knife.run(%w{test yourself --no-listen}, Chef::Application::Knife.options)
+        knife_command = Chef::Knife.run(%w{test yourself --no-listen}, Chef::Application::Knife.options)
         expect(Chef::Config[:listen]).to be(false)
+        expect(knife_command.config_source(:listen)).to eq(:cli)
       end
 
       context "verbosity is one" do
@@ -345,14 +372,11 @@ describe Chef::Knife do
         end
       end
 
-      # -VV (2) is debug, -VVV (3) is trace
-      [ 2, 3 ].each do |verbosity|
-        it "does not humanize the exception if Chef::Config[:verbosity] is #{verbosity}" do
-          Chef::Config[:verbosity] = verbosity
-          allow(knife).to receive(:run).and_raise(Exception)
-          expect(knife).not_to receive(:humanize_exception)
-          expect { knife.run_with_pretty_exceptions }.to raise_error(Exception)
-        end
+      it "does not humanize the exception if Chef::Config[:verbosity] is two" do
+        Chef::Config[:verbosity] = 2
+        allow(knife).to receive(:run).and_raise(Exception)
+        expect(knife).not_to receive(:humanize_exception)
+        expect { knife.run_with_pretty_exceptions }.to raise_error(Exception)
       end
     end
 
@@ -441,8 +465,8 @@ describe Chef::Knife do
       allow(knife).to receive(:run).and_raise(Net::HTTPClientException.new("403 Forbidden", response))
       allow(knife).to receive(:username).and_return("sadpanda")
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to match(/ERROR: You authenticated successfully to http.+ as sadpanda but you are not authorized for this action/)
-      expect(stderr.string).to match(/Response:  y u no administrator/)
+      expect(stderr.string).to match(%r{ERROR: You authenticated successfully to http.+ as sadpanda but you are not authorized for this action})
+      expect(stderr.string).to match(%r{Response:  y u no administrator})
     end
 
     context "when proxy servers are set" do
@@ -461,9 +485,9 @@ describe Chef::Knife do
         allow(knife).to receive(:run).and_raise(Net::HTTPClientException.new("403 Forbidden", response))
         allow(knife).to receive(:username).and_return("sadpanda")
         knife.run_with_pretty_exceptions
-        expect(stderr.string).to match(/ERROR: You authenticated successfully to http.+ as sadpanda but you are not authorized for this action/)
-        expect(stderr.string).to match(/ERROR: There are proxy servers configured, your Chef server may need to be added to NO_PROXY./)
-        expect(stderr.string).to match(/Response:  y u no administrator/)
+        expect(stderr.string).to match(%r{ERROR: You authenticated successfully to http.+ as sadpanda but you are not authorized for this action})
+        expect(stderr.string).to match(%r{ERROR: There are proxy servers configured, your server url may need to be added to NO_PROXY.})
+        expect(stderr.string).to match(%r{Response:  y u no administrator})
       end
     end
 
@@ -473,8 +497,8 @@ describe Chef::Knife do
       allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "y u search wrong"))
       allow(knife).to receive(:run).and_raise(Net::HTTPClientException.new("400 Bad Request", response))
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to match(/ERROR: The data in your request was invalid/)
-      expect(stderr.string).to match(/Response: y u search wrong/)
+      expect(stderr.string).to match(%r{ERROR: The data in your request was invalid})
+      expect(stderr.string).to match(%r{Response: y u search wrong})
     end
 
     it "formats 404s nicely" do
@@ -483,8 +507,8 @@ describe Chef::Knife do
       allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "nothing to see here"))
       allow(knife).to receive(:run).and_raise(Net::HTTPClientException.new("404 Not Found", response))
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to match(/ERROR: The object you are looking for could not be found/)
-      expect(stderr.string).to match(/Response: nothing to see here/)
+      expect(stderr.string).to match(%r{ERROR: The object you are looking for could not be found})
+      expect(stderr.string).to match(%r{Response: nothing to see here})
     end
 
     it "formats 406s (non-supported API version error) nicely" do
@@ -498,9 +522,9 @@ describe Chef::Knife do
       allow(knife).to receive(:run).and_raise(Net::HTTPClientException.new("406 Not Acceptable", response))
 
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to include("The request that Knife sent was using API version 10000000")
-      expect(stderr.string).to include("The Chef server you sent the request to supports a min API verson of 0 and a max API version of 1")
-      expect(stderr.string).to include("Please either update your Chef client or server to be a compatible set")
+      expect(stderr.string).to match(/The request that .* sent was using API version 10000000./)
+      expect(stderr.string).to match(/The server you sent the request to supports a min API verson of 0 and a max API version of 1./)
+      expect(stderr.string).to match(/Please either update your .* or the server to be a compatible set./)
     end
 
     it "formats 500s nicely" do
@@ -509,8 +533,8 @@ describe Chef::Knife do
       allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "sad trombone"))
       allow(knife).to receive(:run).and_raise(Net::HTTPFatalError.new("500 Internal Server Error", response))
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to match(/ERROR: internal server error/)
-      expect(stderr.string).to match(/Response: sad trombone/)
+      expect(stderr.string).to match(%r{ERROR: internal server error})
+      expect(stderr.string).to match(%r{Response: sad trombone})
     end
 
     it "formats 502s nicely" do
@@ -519,8 +543,8 @@ describe Chef::Knife do
       allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "sadder trombone"))
       allow(knife).to receive(:run).and_raise(Net::HTTPFatalError.new("502 Bad Gateway", response))
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to match(/ERROR: bad gateway/)
-      expect(stderr.string).to match(/Response: sadder trombone/)
+      expect(stderr.string).to match(%r{ERROR: bad gateway})
+      expect(stderr.string).to match(%r{Response: sadder trombone})
     end
 
     it "formats 503s nicely" do
@@ -529,8 +553,8 @@ describe Chef::Knife do
       allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "saddest trombone"))
       allow(knife).to receive(:run).and_raise(Net::HTTPFatalError.new("503 Service Unavailable", response))
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to match(/ERROR: Service temporarily unavailable/)
-      expect(stderr.string).to match(/Response: saddest trombone/)
+      expect(stderr.string).to match(%r{ERROR: Service temporarily unavailable})
+      expect(stderr.string).to match(%r{Response: saddest trombone})
     end
 
     it "formats other HTTP errors nicely" do
@@ -539,16 +563,16 @@ describe Chef::Knife do
       allow(response).to receive(:body).and_return(Chef::JSONCompat.to_json(error: "nobugfixtillyoubuy"))
       allow(knife).to receive(:run).and_raise(Net::HTTPClientException.new("402 Payment Required", response))
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to match(/ERROR: Payment Required/)
-      expect(stderr.string).to match(/Response: nobugfixtillyoubuy/)
+      expect(stderr.string).to match(%r{ERROR: Payment Required})
+      expect(stderr.string).to match(%r{Response: nobugfixtillyoubuy})
     end
 
     it "formats NameError and NoMethodError nicely" do
       allow(knife).to receive(:run).and_raise(NameError.new("Undefined constant FUUU"))
       knife.run_with_pretty_exceptions
-      expect(stderr.string).to match(/ERROR: knife encountered an unexpected error/)
-      expect(stderr.string).to match(/This may be a bug in the 'knife' knife command or plugin/)
-      expect(stderr.string).to match(/Exception: NameError: Undefined constant FUUU/)
+      expect(stderr.string).to match(%r{ERROR: .* encountered an unexpected error})
+      expect(stderr.string).to match(%r{This may be a bug in the 'knife' .* command or plugin})
+      expect(stderr.string).to match(%r{Exception: NameError: Undefined constant FUUU})
     end
 
     it "formats missing private key errors nicely" do
@@ -556,7 +580,7 @@ describe Chef::Knife do
       allow(knife).to receive(:api_key).and_return("/home/root/.chef/no-key-here.pem")
       knife.run_with_pretty_exceptions
       expect(stderr.string).to match(%r{ERROR: Your private key could not be loaded from /home/root/.chef/no-key-here.pem})
-      expect(stderr.string).to match(/Check your configuration file and ensure that your private key is readable/)
+      expect(stderr.string).to match(%r{Check your configuration file and ensure that your private key is readable})
     end
 
     it "formats connection refused errors nicely" do
@@ -565,8 +589,8 @@ describe Chef::Knife do
       # Errno::ECONNREFUSED message differs by platform
       # *nix = Errno::ECONNREFUSED: Connection refused
       # win32: Errno::ECONNREFUSED: No connection could be made because the target machine actively refused it.
-      expect(stderr.string).to match(/ERROR: Network Error: .* - y u no shut up/)
-      expect(stderr.string).to match(/Check your knife configuration and network settings/)
+      expect(stderr.string).to match(%r{ERROR: Network Error: .* - y u no shut up})
+      expect(stderr.string).to match(%r{Check your .* configuration and network settings})
     end
 
     it "formats SSL errors nicely and suggests to use `knife ssl check` and `knife ssl fetch`" do
@@ -577,11 +601,11 @@ describe Chef::Knife do
 
       expected_message = <<~MSG
         ERROR: Could not establish a secure connection to the server.
-        Use `knife ssl check` to troubleshoot your SSL configuration.
-        If your Chef Server uses a self-signed certificate, you can use
-        `knife ssl fetch` to make knife trust the server's certificates.
+        Use `.* ssl check` to troubleshoot your SSL configuration.
+        If your server uses a self-signed certificate, you can use
+        `.* ssl fetch` to make .* trust the server's certificates.
       MSG
-      expect(stderr.string).to include(expected_message)
+      expect(stderr.string).to match(expected_message)
     end
 
   end

data/spec/unit/lwrp_spec.rb

@@ -199,7 +199,7 @@ describe "LWRP" do
     end
 
     it "should create a method for each attribute" do
-      expect(get_lwrp(:lwrp_foo).new("blah").methods.map(&:to_sym)).to include(:monkey)
+      expect(get_lwrp(:lwrp_foo).new("blah").methods.map { |m| m.to_sym }).to include(:monkey)
     end
 
     it "should build attribute methods that respect validation rules" do
@@ -264,12 +264,12 @@ describe "LWRP" do
       let(:lwrp) do
         Class.new(Chef::Resource::LWRPBase) do
           actions :eat, :sleep
-          default_action %i{eat sleep}
+          default_action [:eat, :sleep]
         end
       end
 
       it "returns the array of default actions" do
-        expect(lwrp.default_action).to eq(%i{eat sleep})
+        expect(lwrp.default_action).to eq([:eat, :sleep])
       end
     end
 
@@ -287,7 +287,7 @@ describe "LWRP" do
         end
 
         it "delegates #actions to the parent" do
-          expect(child.actions).to eq(%i{nothing eat sleep})
+          expect(child.actions).to eq([:nothing, :eat, :sleep])
         end
 
         it "delegates #default_action to the parent" do
@@ -304,7 +304,7 @@ describe "LWRP" do
         end
 
         it "does not delegate #actions to the parent" do
-          expect(child.actions).to eq(%i{nothing dont_eat dont_sleep})
+          expect(child.actions).to eq([:nothing, :dont_eat, :dont_sleep])
         end
 
         it "does not delegate #default_action to the parent" do
@@ -322,7 +322,7 @@ describe "LWRP" do
         end
 
         it "amends actions when they are already defined" do
-          expect(child.actions).to eq(%i{nothing eat sleep drink})
+          expect(child.actions).to eq([:nothing, :eat, :sleep, :drink])
         end
       end
     end
@@ -330,40 +330,40 @@ describe "LWRP" do
     describe "when actions is set to an array" do
       let(:resource_class) do
         Class.new(Chef::Resource::LWRPBase) do
-          actions %i{eat sleep}
+          actions [ :eat, :sleep ]
         end
       end
       let(:resource) do
         resource_class.new("blah")
       end
       it "actions includes those actions" do
-        expect(resource_class.actions).to eq %i{nothing eat sleep}
+        expect(resource_class.actions).to eq [ :nothing, :eat, :sleep ]
       end
       it "allowed_actions includes those actions" do
-        expect(resource_class.allowed_actions).to eq %i{nothing eat sleep}
+        expect(resource_class.allowed_actions).to eq [ :nothing, :eat, :sleep ]
       end
       it "resource.allowed_actions includes those actions" do
-        expect(resource.allowed_actions).to eq %i{nothing eat sleep}
+        expect(resource.allowed_actions).to eq [ :nothing, :eat, :sleep ]
       end
     end
 
     describe "when allowed_actions is set to an array" do
       let(:resource_class) do
         Class.new(Chef::Resource::LWRPBase) do
-          allowed_actions %i{eat sleep}
+          allowed_actions [ :eat, :sleep ]
         end
       end
       let(:resource) do
         resource_class.new("blah")
       end
       it "actions includes those actions" do
-        expect(resource_class.actions).to eq %i{nothing eat sleep}
+        expect(resource_class.actions).to eq [ :nothing, :eat, :sleep ]
       end
       it "allowed_actions includes those actions" do
-        expect(resource_class.allowed_actions).to eq %i{nothing eat sleep}
+        expect(resource_class.allowed_actions).to eq [ :nothing, :eat, :sleep ]
       end
       it "resource.allowed_actions includes those actions" do
-        expect(resource.allowed_actions).to eq %i{nothing eat sleep}
+        expect(resource.allowed_actions).to eq [ :nothing, :eat, :sleep ]
       end
     end
   end
@@ -590,7 +590,7 @@ describe "LWRP" do
 
     it "get_lwrp(:lwrp_once).new is an instance of the LWRP class" do
       lwrp = get_lwrp(:lwrp_once).new("hi")
-      expect(lwrp.is_a?(test_lwrp_class)).to be_truthy
+      expect(lwrp.kind_of?(test_lwrp_class)).to be_truthy
       expect(lwrp.is_a?(test_lwrp_class)).to be_truthy
       expect(get_lwrp(:lwrp_once) === lwrp).to be_truthy
       expect(test_lwrp_class === lwrp).to be_truthy
@@ -603,28 +603,28 @@ describe "LWRP" do
 
       it "subclass.new is a subclass" do
         lwrp = subclass.new("hi")
-        expect(lwrp.is_a?(subclass)).to be_truthy
+        expect(lwrp.kind_of?(subclass)).to be_truthy
         expect(lwrp.is_a?(subclass)).to be_truthy
         expect(subclass === lwrp).to be_truthy
         expect(lwrp.class === subclass)
       end
       it "subclass.new is an instance of the LWRP class" do
         lwrp = subclass.new("hi")
-        expect(lwrp.is_a?(test_lwrp_class)).to be_truthy
+        expect(lwrp.kind_of?(test_lwrp_class)).to be_truthy
         expect(lwrp.is_a?(test_lwrp_class)).to be_truthy
         expect(test_lwrp_class === lwrp).to be_truthy
         expect(lwrp.class === test_lwrp_class)
       end
       it "subclass.new is a get_lwrp(:lwrp_once)" do
         lwrp = subclass.new("hi")
-        expect(lwrp.is_a?(get_lwrp(:lwrp_once))).to be_truthy
+        expect(lwrp.kind_of?(get_lwrp(:lwrp_once))).to be_truthy
         expect(lwrp.is_a?(get_lwrp(:lwrp_once))).to be_truthy
         expect(get_lwrp(:lwrp_once) === lwrp).to be_truthy
         expect(lwrp.class === get_lwrp(:lwrp_once))
       end
       it "get_lwrp(:lwrp_once).new is *not* a subclass" do
         lwrp = get_lwrp(:lwrp_once).new("hi")
-        expect(lwrp.is_a?(subclass)).to be_falsey
+        expect(lwrp.kind_of?(subclass)).to be_falsey
         expect(lwrp.is_a?(subclass)).to be_falsey
         expect(subclass === lwrp.class).to be_falsey
         expect(subclass === get_lwrp(:lwrp_once)).to be_falsey