chef 14.2.0-universal-mingw32 → 14.3.37-universal-mingw32

data/spec/tiny_server.rb

@@ -38,7 +38,7 @@ module TinyServer
       # SSLEnable: options[:ssl],
       # SSLCertName: [ [ 'CN', WEBrick::Utils::getservername ] ],
       AccessLog: [], # Remove this option to enable the access log when debugging.
-    }
+    }.freeze
 
     def initialize(**options)
       @options = DEFAULT_OPTIONS.merge(options)
@@ -101,10 +101,10 @@ module TinyServer
   class API
     include Singleton
 
-    GET     = "GET"
-    PUT     = "PUT"
-    POST    = "POST"
-    DELETE  = "DELETE"
+    GET     = "GET".freeze
+    PUT     = "PUT".freeze
+    POST    = "POST".freeze
+    DELETE  = "DELETE".freeze
 
     attr_reader :routes
 
@@ -136,8 +136,8 @@ module TinyServer
       if response = response_for_request(env)
         response.call
       else
-        debug_info = { :message => "no data matches the request for #{env['REQUEST_URI']}",
-                       :available_routes => @routes, :request => env }
+        debug_info = { message: "no data matches the request for #{env['REQUEST_URI']}",
+                       available_routes: @routes, request: env }
         # Uncomment me for glorious debugging
         # pp :not_found => debug_info
         [404, { "Content-Type" => "application/json" }, [ Chef::JSONCompat.to_json(debug_info) ]]
@@ -170,7 +170,7 @@ module TinyServer
   end
 
   class Response
-    HEADERS = { "Content-Type" => "application/json" }
+    HEADERS = { "Content-Type" => "application/json" }.freeze
 
     def initialize(response_code = 200, data = nil, headers = nil, &block)
       @response_code, @data = response_code, data

data/spec/unit/api_client/registration_spec.rb

@@ -38,11 +38,11 @@ describe Chef::ApiClient::Registration do
   let(:http_mock) { double("Chef::ServerAPI mock") }
 
   let(:expected_post_data) do
-    { :name => client_name, :admin => false, :public_key => generated_public_key.to_pem }
+    { name: client_name, admin: false, public_key: generated_public_key.to_pem }
   end
 
   let(:expected_put_data) do
-    { :name => client_name, :admin => false, :public_key => generated_public_key.to_pem }
+    { name: client_name, admin: false, public_key: generated_public_key.to_pem }
   end
 
   let(:server_v10_response) do
@@ -108,28 +108,28 @@ describe Chef::ApiClient::Registration do
     end
 
     it "posts a locally generated public key to the server to create a client" do
-      expect(http_mock).to receive(:post).
-        with("clients", expected_post_data).
-        and_return(create_with_pkey_response)
+      expect(http_mock).to receive(:post)
+        .with("clients", expected_post_data)
+        .and_return(create_with_pkey_response)
       expect(registration.run.public_key).to eq(create_with_pkey_response["chef_key"]["public_key"])
       expect(OpenSSL::PKey::RSA.new(registration.private_key).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
     end
 
     it "puts a locally generated public key to the server to update a client" do
-      expect(http_mock).to receive(:post).
-        with("clients", expected_post_data).
-        and_raise(exception_409)
-      expect(http_mock).to receive(:put).
-        with("clients/#{client_name}", expected_put_data).
-        and_return(update_with_pkey_response)
+      expect(http_mock).to receive(:post)
+        .with("clients", expected_post_data)
+        .and_raise(exception_409)
+      expect(http_mock).to receive(:put)
+        .with("clients/#{client_name}", expected_put_data)
+        .and_return(update_with_pkey_response)
       expect(registration.run.public_key).to eq(update_with_pkey_response["public_key"].to_pem)
       expect(OpenSSL::PKey::RSA.new(registration.private_key).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
     end
 
     it "writes the generated private key to disk" do
-      expect(http_mock).to receive(:post).
-        with("clients", expected_post_data).
-        and_return(create_with_pkey_response)
+      expect(http_mock).to receive(:post)
+        .with("clients", expected_post_data)
+        .and_return(create_with_pkey_response)
       registration.run
       expect(OpenSSL::PKey::RSA.new(IO.read(key_location)).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
     end
@@ -137,9 +137,9 @@ describe Chef::ApiClient::Registration do
     context "and the client already exists on a Chef 11 server" do
       it "requests a new key from the server and saves it" do
         expect(http_mock).to receive(:post).and_raise(exception_409)
-        expect(http_mock).to receive(:put).
-          with("clients/#{client_name}", expected_put_data).
-          and_return(update_with_pkey_response)
+        expect(http_mock).to receive(:put)
+          .with("clients/#{client_name}", expected_put_data)
+          .and_return(update_with_pkey_response)
         expect(registration.run.public_key).to eq(update_with_pkey_response["public_key"].to_pem)
         expect(OpenSSL::PKey::RSA.new(registration.private_key).to_s).to eq(OpenSSL::PKey::RSA.new(generated_private_key_pem).to_s)
       end
@@ -148,11 +148,11 @@ describe Chef::ApiClient::Registration do
     context "when local key generation is disabled" do
 
       let(:expected_post_data) do
-        { :name => client_name, :admin => false }
+        { name: client_name, admin: false }
       end
 
       let(:expected_put_data) do
-        { :name => client_name, :admin => false, :private_key => true }
+        { name: client_name, admin: false, private_key: true }
       end
 
       before do
@@ -161,9 +161,9 @@ describe Chef::ApiClient::Registration do
       end
 
       it "creates a new ApiClient on the server using the validator identity" do
-        expect(http_mock).to receive(:post).
-          with("clients", expected_post_data).
-          and_return(server_v10_response)
+        expect(http_mock).to receive(:post)
+          .with("clients", expected_post_data)
+          .and_return(server_v10_response)
         expect(registration.run.private_key).to eq(server_v10_response["private_key"])
         expect(registration.private_key).to eq("--begin rsa key etc--")
       end
@@ -171,9 +171,9 @@ describe Chef::ApiClient::Registration do
       context "and the client already exists on a Chef 11 server" do
         it "requests a new key from the server and saves it" do
           expect(http_mock).to receive(:post).and_raise(exception_409)
-          expect(http_mock).to receive(:put).
-            with("clients/#{client_name}", expected_put_data).
-            and_return(server_v11_response)
+          expect(http_mock).to receive(:put)
+            .with("clients/#{client_name}", expected_put_data)
+            .and_return(server_v11_response)
           expect(registration.run).to eq(server_v11_response)
           expect(registration.private_key).to eq("--begin rsa key etc--")
         end
@@ -181,11 +181,11 @@ describe Chef::ApiClient::Registration do
 
       context "and the client already exists on a Chef 10 server" do
         it "requests a new key from the server and saves it" do
-          expect(http_mock).to receive(:post).with("clients", expected_post_data).
-            and_raise(exception_409)
-          expect(http_mock).to receive(:put).
-            with("clients/#{client_name}", expected_put_data).
-            and_return(server_v10_response)
+          expect(http_mock).to receive(:post).with("clients", expected_post_data)
+            .and_raise(exception_409)
+          expect(http_mock).to receive(:put)
+            .with("clients/#{client_name}", expected_put_data)
+            .and_return(server_v10_response)
           expect(registration.run.private_key).to eq(server_v10_response["private_key"])
           expect(registration.private_key).to eq("--begin rsa key etc--")
         end

data/spec/unit/api_client_spec.rb

@@ -302,9 +302,9 @@ describe Chef::ApiClient do
           @api_client_with_key = Chef::ApiClient.new
           @api_client_with_key.name("lost-my-key")
           @api_client_with_key.private_key("the new private key")
-          expect(@http_client).to receive(:put).
-            with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :validator => false, :private_key => true).
-            and_return(@api_client_with_key)
+          expect(@http_client).to receive(:put)
+            .with("clients/lost-my-key", name: "lost-my-key", admin: false, validator: false, private_key: true)
+            .and_return(@api_client_with_key)
         end
 
         it "returns an ApiClient with a private key" do
@@ -320,9 +320,9 @@ describe Chef::ApiClient do
       context "and the client exists on a Chef 10-like server" do
         before do
           @api_client_with_key = { "name" => "lost-my-key", "private_key" => "the new private key" }
-          expect(@http_client).to receive(:put).
-            with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :validator => false, :private_key => true).
-            and_return(@api_client_with_key)
+          expect(@http_client).to receive(:put)
+            .with("clients/lost-my-key", name: "lost-my-key", admin: false, validator: false, private_key: true)
+            .and_return(@api_client_with_key)
         end
 
         it "returns an ApiClient with a private key" do

data/spec/unit/api_client_v1_spec.rb

@@ -324,13 +324,13 @@ describe Chef::ApiClientV1 do
   end
 
   describe "Versioned API Interactions" do
-    let(:response_406) { OpenStruct.new(:code => "406") }
+    let(:response_406) { OpenStruct.new(code: "406") }
     let(:exception_406) { Net::HTTPServerException.new("406 Not Acceptable", response_406) }
     let(:payload) do
       {
-        :name => "some_name",
-        :validator => true,
-        :admin => true,
+        name: "some_name",
+        validator: true,
+        admin: true,
       }
     end
 
@@ -389,7 +389,7 @@ describe Chef::ApiClientV1 do
             end
 
             it "updates the client with only the name" do
-              expect(rest). to receive(:put).with("clients/some_name", { :name => "some_name" }).and_return({ :name => "some_name" })
+              expect(rest). to receive(:put).with("clients/some_name", { name: "some_name" }).and_return({ name: "some_name" })
               @client.update
             end
           end
@@ -437,7 +437,7 @@ describe Chef::ApiClientV1 do
     describe "reregister" do
       context "when server API V0 is valid on the Chef Server receiving the request" do
         it "creates a new object via the API" do
-          expect(@client.chef_rest_v0).to receive(:put).with("clients/#{@client.name}", payload.merge({ :private_key => true })).and_return({})
+          expect(@client.chef_rest_v0).to receive(:put).with("clients/#{@client.name}", payload.merge({ private_key: true })).and_return({})
           @client.reregister
         end
       end # when server API V0 is valid on the Chef Server receiving the request

data/spec/unit/application/apply_spec.rb

@@ -37,7 +37,7 @@ describe Chef::Application::Apply do
     before do
       @recipe_file_name = "foo.rb"
       @recipe_path = File.expand_path(@recipe_file_name)
-      @recipe_file = double("Tempfile (mock)", :read => @recipe_text)
+      @recipe_file = double("Tempfile (mock)", read: @recipe_text)
       allow(@app).to receive(:open).with(@recipe_path).and_return(@recipe_file)
       allow(File).to receive(:exist?).with(@recipe_path).and_return(true)
       allow(Chef::Application).to receive(:fatal!).and_return(true)
@@ -96,13 +96,13 @@ describe Chef::Application::Apply do
   end
   describe "when the json_attribs configuration option is specified" do
     let(:json_attribs) { { "a" => "b" } }
-    let(:config_fetcher) { double(Chef::ConfigFetcher, :fetch_json => json_attribs) }
+    let(:config_fetcher) { double(Chef::ConfigFetcher, fetch_json: json_attribs) }
     let(:json_source) { "https://foo.com/foo.json" }
 
     before do
       Chef::Config[:json_attribs] = json_source
-      expect(Chef::ConfigFetcher).to receive(:new).with(json_source).
-        and_return(config_fetcher)
+      expect(Chef::ConfigFetcher).to receive(:new).with(json_source)
+        .and_return(config_fetcher)
     end
 
     it "reads the JSON attributes from the specified source" do

data/spec/unit/application/client_spec.rb

@@ -121,27 +121,27 @@ describe Chef::Application::Client, "reconfigure" do
     describe "--named-run-list" do
       it_behaves_like "sets the configuration",
                       "--named-run-list arglebargle-example",
-                      :named_run_list => "arglebargle-example"
+                      named_run_list: "arglebargle-example"
     end
 
     describe "--no-listen" do
-      it_behaves_like "sets the configuration", "--no-listen", :listen => false
+      it_behaves_like "sets the configuration", "--no-listen", listen: false
     end
 
     describe "--daemonize", :unix_only do
       context "with no value" do
         it_behaves_like "sets the configuration", "--daemonize",
-                        :daemonize => true
+                        daemonize: true
       end
 
       context "with an integer value" do
         it_behaves_like "sets the configuration", "--daemonize 5",
-                        :daemonize => 5
+                        daemonize: 5
       end
 
       context "with a non-integer value" do
         it_behaves_like "sets the configuration", "--daemonize foo",
-                        :daemonize => true
+                        daemonize: true
       end
     end
 
@@ -178,17 +178,17 @@ describe Chef::Application::Client, "reconfigure" do
     describe "--config-option" do
       context "with a single value" do
         it_behaves_like "sets the configuration", "--config-option chef_server_url=http://example",
-                        :chef_server_url => "http://example"
+                        chef_server_url: "http://example"
       end
 
       context "with two values" do
         it_behaves_like "sets the configuration", "--config-option chef_server_url=http://example --config-option policy_name=web",
-                        :chef_server_url => "http://example", :policy_name => "web"
+                        chef_server_url: "http://example", policy_name: "web"
       end
 
       context "with a boolean value" do
         it_behaves_like "sets the configuration", "--config-option minimal_ohai=true",
-                        :minimal_ohai => true
+                        minimal_ohai: true
       end
 
       context "with an empty value" do
@@ -321,14 +321,14 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
   describe "when the json_attribs configuration option is specified" do
 
     let(:json_attribs) { { "a" => "b" } }
-    let(:config_fetcher) { double(Chef::ConfigFetcher, :fetch_json => json_attribs) }
+    let(:config_fetcher) { double(Chef::ConfigFetcher, fetch_json: json_attribs) }
     let(:json_source) { "https://foo.com/foo.json" }
 
     before do
       allow(app).to receive(:configure_chef).and_return(true)
       Chef::Config[:json_attribs] = json_source
-      expect(Chef::ConfigFetcher).to receive(:new).with(json_source).
-        and_return(config_fetcher)
+      expect(Chef::ConfigFetcher).to receive(:new).with(json_source)
+        .and_return(config_fetcher)
     end
 
     it "reads the JSON attributes from the specified source" do

data/spec/unit/application/knife_spec.rb

@@ -24,9 +24,9 @@ describe Chef::Application::Knife do
   before(:all) do
     class NoopKnifeCommand < Chef::Knife
       option :opt_with_default,
-        :short => "-D VALUE",
-        :long => "-optwithdefault VALUE",
-        :default => "default-value"
+        short: "-D VALUE",
+        long: "-optwithdefault VALUE",
+        default: "default-value"
 
       def run
       end

data/spec/unit/application/solo_spec.rb

@@ -93,13 +93,13 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
 
       describe "when the json_attribs configuration option is specified" do
         let(:json_attribs) { { "a" => "b" } }
-        let(:config_fetcher) { double(Chef::ConfigFetcher, :fetch_json => json_attribs) }
+        let(:config_fetcher) { double(Chef::ConfigFetcher, fetch_json: json_attribs) }
         let(:json_source) { "https://foo.com/foo.json" }
 
         before do
           Chef::Config[:json_attribs] = json_source
-          expect(Chef::ConfigFetcher).to receive(:new).with(json_source).
-            and_return(config_fetcher)
+          expect(Chef::ConfigFetcher).to receive(:new).with(json_source)
+            .and_return(config_fetcher)
         end
 
         it "reads the JSON attributes from the specified source" do
@@ -130,7 +130,7 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
 
       it "fetches the recipe_url first when both json_attribs and recipe_url are specified" do
         json_attribs = { "a" => "b" }
-        config_fetcher = instance_double("Chef::ConfigFetcher", :fetch_json => json_attribs)
+        config_fetcher = instance_double("Chef::ConfigFetcher", fetch_json: json_attribs)
 
         Chef::Config[:json_attribs] = "https://foo.com/foo.json"
         Chef::Config[:recipe_url] = "http://icanhas.cheezburger.com/lolcats"
@@ -208,7 +208,7 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
     it "sets the repo path" do
       expect(Chef::Config).to receive(:find_chef_repo_path).and_return("/var/chef")
       app.reconfigure
-      expect(Chef::Config.has_key?(:chef_repo_path)).to be_truthy
+      expect(Chef::Config.key?(:chef_repo_path)).to be_truthy
       expect(Chef::Config[:chef_repo_path]).to eq ("/var/chef")
     end
 

data/spec/unit/application_spec.rb

@@ -107,7 +107,7 @@ describe Chef::Application do
 
       it "should parse the commandline options" do
         expect(@app).to receive(:parse_options).and_return(true)
-        @app.config[:config_file] = "/etc/chef/default.rb" #have a config file set, to prevent triggering error block
+        @app.config[:config_file] = "/etc/chef/default.rb" # have a config file set, to prevent triggering error block
         @app.configure_chef
       end
 
@@ -127,9 +127,9 @@ describe Chef::Application do
           # force let binding to get evaluated or else we stub Pathname.new before we try to use it.
           config_location_pathname
           allow(Pathname).to receive(:new).with(config_location).and_return(config_location_pathname)
-          expect(File).to receive(:read).
-            with(config_location).
-            and_return(config_content)
+          expect(File).to receive(:read)
+            .with(config_location)
+            .and_return(config_content)
         end
 
         it "should configure chef::config from a file" do
@@ -138,7 +138,7 @@ describe Chef::Application do
         end
 
         it "should merge the local config hash into chef::config" do
-          #File.should_receive(:open).with("/etc/chef/default.rb").and_yield(@config_file)
+          # File.should_receive(:open).with("/etc/chef/default.rb").and_yield(@config_file)
           @app.configure_chef
           expect(Chef::Config.rspec_ran).to eq("true")
         end
@@ -393,11 +393,11 @@ describe Chef::Application do
 
     def raises_informative_fatals_on_configure_chef
       config_file_regexp = Regexp.new @app.config[:config_file]
-      expect(Chef::Log).to receive(:fatal).
-        with(/Configuration error/)
-      expect(Chef::Log).to receive(:fatal).
-        with(config_file_regexp).
-        at_least(1).times
+      expect(Chef::Log).to receive(:fatal)
+        .with(/Configuration error/)
+      expect(Chef::Log).to receive(:fatal)
+        .with(config_file_regexp)
+        .at_least(1).times
       @app.configure_chef
     end
 
@@ -447,7 +447,7 @@ describe Chef::Application do
       ARGV.replace(@original_argv)
     end
 
-    let(:fake_config_fetcher) { instance_double(Chef::ConfigFetcher, expanded_path: "/thisbetternotexist", :"config_missing?" => false, read_config: "" ) }
+    let(:fake_config_fetcher) { instance_double(Chef::ConfigFetcher, expanded_path: "/thisbetternotexist", "config_missing?": false, read_config: "" ) }
 
     it "reading a mixlib-config default works" do
       @app.parse_options

data/spec/unit/audit/audit_event_proxy_spec.rb

@@ -35,19 +35,19 @@ describe Chef::Audit::AuditEventProxy do
 
     let(:description) { "poots" }
     let(:group) do
-      double("ExampleGroup", :parent_groups => parents,
-                             :description => description) end
-    let(:notification) { double("Notification", :group => group) }
+      double("ExampleGroup", parent_groups: parents,
+                             description: description) end
+    let(:notification) { double("Notification", group: group) }
 
     context "when notified from a top-level example group" do
 
       let(:parents) { [double("ExampleGroup")] }
 
       it "notifies control_group_started event" do
-        expect(Chef::Log).to receive(:trace).
-          with("Entered \`control_group\` block named poots")
-        expect(events).to receive(:control_group_started).
-          with(description)
+        expect(Chef::Log).to receive(:trace)
+          .with("Entered \`control_group\` block named poots")
+        expect(events).to receive(:control_group_started)
+          .with(description)
         audit_event_proxy.example_group_started(notification)
       end
     end
@@ -66,9 +66,9 @@ describe Chef::Audit::AuditEventProxy do
   describe "#stop" do
 
     let(:examples) { [] }
-    let(:notification) { double("Notification", :examples => examples) }
+    let(:notification) { double("Notification", examples: examples) }
     let(:exception) { nil }
-    let(:example) { double("Example", :exception => exception) }
+    let(:example) { double("Example", exception: exception) }
     let(:control_group_name) { "audit test" }
     let(:control_data) { double("ControlData") }
 
@@ -87,14 +87,14 @@ describe Chef::Audit::AuditEventProxy do
       let(:excpetion) { nil }
 
       before do
-        allow(audit_event_proxy).to receive(:build_control_from).
-          with(example).
-          and_return([control_group_name, control_data])
+        allow(audit_event_proxy).to receive(:build_control_from)
+          .with(example)
+          .and_return([control_group_name, control_data])
       end
 
       it "notifies events" do
-        expect(events).to receive(:control_example_success).
-          with(control_group_name, control_data)
+        expect(events).to receive(:control_example_success)
+          .with(control_group_name, control_data)
         audit_event_proxy.stop(notification)
       end
     end
@@ -105,14 +105,14 @@ describe Chef::Audit::AuditEventProxy do
       let(:exception) { double("ExpectationNotMet") }
 
       before do
-        allow(audit_event_proxy).to receive(:build_control_from).
-          with(example).
-          and_return([control_group_name, control_data])
+        allow(audit_event_proxy).to receive(:build_control_from)
+          .with(example)
+          .and_return([control_group_name, control_data])
       end
 
       it "notifies events" do
-        expect(events).to receive(:control_example_failure).
-          with(control_group_name, control_data, exception)
+        expect(events).to receive(:control_example_failure)
+          .with(control_group_name, control_data, exception)
         audit_event_proxy.stop(notification)
       end
     end
@@ -122,29 +122,29 @@ describe Chef::Audit::AuditEventProxy do
       let(:examples) { [example] }
 
       let(:example) do
-        double("Example", :metadata => metadata,
-                          :description => example_description,
-                          :full_description => full_description, :exception => nil) end
+        double("Example", metadata: metadata,
+                          description: example_description,
+                          full_description: full_description, exception: nil) end
 
       let(:metadata) do
         {
-          :described_class => described_class,
-          :example_group => example_group,
-          :line_number => line,
+          described_class: described_class,
+          example_group: example_group,
+          line_number: line,
         }
       end
 
       let(:example_group) do
         {
-          :description => group_description,
-          :parent_example_group => parent_group,
+          description: group_description,
+          parent_example_group: parent_group,
         }
       end
 
       let(:parent_group) do
         {
-          :description => control_group_name,
-          :parent_example_group => nil,
+          description: control_group_name,
+          parent_example_group: nil,
         }
       end
 
@@ -152,12 +152,12 @@ describe Chef::Audit::AuditEventProxy do
 
       let(:control_data) do
         {
-          :name => example_description,
-          :desc => full_description,
-          :resource_type => resource_type,
-          :resource_name => resource_name,
-          :context => context,
-          :line_number => line,
+          name: example_description,
+          desc: full_description,
+          resource_type: resource_type,
+          resource_name: resource_name,
+          context: context,
+          line_number: line,
         }
       end
 
@@ -165,17 +165,17 @@ describe Chef::Audit::AuditEventProxy do
 
         before do
           if described_class
-            allow(described_class).to receive(:instance_variable_get).
-              with(:@name).
-              and_return(resource_name)
-            allow(described_class.class).to receive(:name).
-              and_return(described_class.class)
+            allow(described_class).to receive(:instance_variable_get)
+              .with(:@name)
+              .and_return(resource_name)
+            allow(described_class.class).to receive(:name)
+              .and_return(described_class.class)
           end
         end
 
         it "returns the controls block name and example metadata for reporting" do
-          expect(events).to receive(:control_example_success).
-            with(control_group_name, control_data)
+          expect(events).to receive(:control_example_success)
+            .with(control_group_name, control_data)
           audit_event_proxy.stop(notification)
         end
       end
@@ -227,7 +227,7 @@ describe Chef::Audit::AuditEventProxy do
         # Metadata fields
         let(:described_class) do
           double("Serverspec::Type::Port",
-          :class => "Serverspec::Type::Port", :name => resource_name) end
+          class: "Serverspec::Type::Port", name: resource_name) end
 
         # Control data fields
         let(:resource_type) { "Port" }
@@ -288,20 +288,20 @@ describe Chef::Audit::AuditEventProxy do
         # Metadata parts
         let(:described_class) do
           double("Serverspec::Type::File",
-          :class => "Serverspec::Type::File", :name => resource_name) end
+          class: "Serverspec::Type::File", name: resource_name) end
 
         # Example group parts
         let(:parent_group) do
           {
-            :description => outer_group_description,
-            :parent_example_group => control_group,
+            description: outer_group_description,
+            parent_example_group: control_group,
           }
         end
 
         let(:control_group) do
           {
-            :description => control_group_name,
-            :parent_example_group => nil,
+            description: control_group_name,
+            parent_example_group: nil,
           }
         end