puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/type/filebucket_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:filebucket) do
@@ -77,26 +76,26 @@ describe Puppet::Type.type(:filebucket) do
 
   describe "when creating the filebucket" do
     before do
-      @bucket = stub 'bucket', :name= => nil
+      @bucket = double('bucket', :name= => nil)
     end
 
     it "should use any provided path" do
       path = make_absolute("/foo/bar")
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => path
-      Puppet::FileBucket::Dipper.expects(:new).with(:Path => path).returns @bucket
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Path => path).and_return(@bucket)
       bucket.bucket
     end
 
     it "should use any provided server and port" do
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :server => "myserv", :port => "myport", :path => false
-      Puppet::FileBucket::Dipper.expects(:new).with(:Server => "myserv", :Port => "myport").returns @bucket
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Server => "myserv", :Port => "myport").and_return(@bucket)
       bucket.bucket
     end
 
     it "should not try to guess server or port if the path is unset and no server is provided" do
       Puppet.settings[:server] = "myserv"
       Puppet.settings[:server_list] = ['server_list_0', 'server_list_1']
-      Puppet::FileBucket::Dipper.expects(:new).with(:Server => nil, :Port => nil).returns @bucket
+      expect(Puppet::FileBucket::Dipper).to receive(:new).with(:Server => nil, :Port => nil).and_return(@bucket)
 
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => false
       bucket.bucket

data/spec/unit/type/group_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:group) do
@@ -50,20 +49,20 @@ describe Puppet::Type.type(:group) do
 
   it "should call 'create' to create the group" do
     group = @class.new(:name => "foo", :ensure => :present)
-    group.provider.expects(:create)
+    expect(group.provider).to receive(:create)
     group.parameter(:ensure).sync
   end
 
   it "should call 'delete' to remove the group" do
     group = @class.new(:name => "foo", :ensure => :absent)
-    group.provider.expects(:delete)
+    expect(group.provider).to receive(:delete)
     group.parameter(:ensure).sync
   end
 
   it "delegates the existence check to its provider" do
     provider = @class.provide(:testing) {}
     provider_instance = provider.new
-    provider_instance.expects(:exists?).returns true
+    expect(provider_instance).to receive(:exists?).and_return(true)
 
     type = @class.new(:name => "group", :provider => provider_instance)
 
@@ -71,7 +70,6 @@ describe Puppet::Type.type(:group) do
   end
 
   describe "should delegate :members implementation to the provider:"  do
-
     let (:provider) do
       @class.provide(:testing) do
         has_features :manages_members
@@ -85,13 +83,13 @@ describe Puppet::Type.type(:group) do
     let (:type) { @class.new(:name => "group", :provider => provider_instance, :members => ['user1']) }
 
     it "insync? calls members_insync?" do
-      provider_instance.expects(:members_insync?).with(['user1'], ['user1']).returns true
+      expect(provider_instance).to receive(:members_insync?).with(['user1'], ['user1']).and_return(true)
       expect(type.property(:members).insync?(['user1'])).to be_truthy
     end
 
     it "is_to_s and should_to_s call members_to_s" do
-      provider_instance.expects(:members_to_s).with(['user1', 'user2']).returns "user1 (), user2 ()"
-      provider_instance.expects(:members_to_s).with(['user1']).returns "user1 ()"
+      expect(provider_instance).to receive(:members_to_s).with(['user1', 'user2']).and_return("user1 (), user2 ()")
+      expect(provider_instance).to receive(:members_to_s).with(['user1']).and_return("user1 ()")
 
       expect(type.property(:members).is_to_s('user1')).to eq('user1 ()')
       expect(type.property(:members).should_to_s('user1,user2')).to eq('user1 (), user2 ()')

data/spec/unit/type/host_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 host = Puppet::Type.type(:host)
@@ -9,7 +8,7 @@ describe host do
     @class = host
     @catalog = Puppet::Resource::Catalog.new
     @provider = FakeHostProvider.new
-    @resource = stub 'resource', :resource => nil, :provider => @provider
+    @resource = double('resource', :resource => nil, :provider => @provider)
   end
 
   it "should have :name be its namevar" do
@@ -659,7 +658,7 @@ describe host do
 
     it "should also use the specified delimiter for joining" do
       @host_aliases = @class.attrclass(:host_aliases).new(:resource => @resource, :should => %w{foo bar})
-      @host_aliases.stubs(:delimiter).returns "\t"
+      allow(@host_aliases).to receive(:delimiter).and_return("\t")
 
       @host_aliases.sync
 

data/spec/unit/type/interface_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:interface) do
@@ -27,8 +26,8 @@ describe Puppet::Type.type(:interface) do
 
   describe "when validating attribute values" do
     before do
-      @provider = stub 'provider', :class => Puppet::Type.type(:interface).defaultprovider, :clear => nil
-      Puppet::Type.type(:interface).defaultprovider.stubs(:new).returns(@provider)
+      @provider = double('provider', :class => Puppet::Type.type(:interface).defaultprovider, :clear => nil)
+      allow(Puppet::Type.type(:interface).defaultprovider).to receive(:new).and_return(@provider)
     end
 
     it "should support :present as a value to :ensure" do

data/spec/unit/type/k5login_spec.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 require 'fileutils'
 require 'puppet/type'
@@ -84,7 +83,7 @@ describe Puppet::Type.type(:k5login), :unless => Puppet.features.microsoft_windo
 
             context "with selinux" do
               it "should return correct values based on SELinux state" do
-                sel_param.stubs(:debug)
+                allow(sel_param).to receive(:debug)
                 expectedresult = case param
                   when :seluser; "user_u"
                   when :selrole; "object_r"
@@ -97,14 +96,14 @@ describe Puppet::Type.type(:k5login), :unless => Puppet.features.microsoft_windo
 
             context 'without selinux' do
               it 'should not try to determine the initial state' do
-                Puppet::Type::K5login::ProviderK5login.any_instance.stubs(:selinux_support?).returns false
+                allow_any_instance_of(Puppet::Type::K5login::ProviderK5login).to receive(:selinux_support?).and_return(false)
 
                 expect(subject[:selrole]).to be_nil
               end
 
               it "should do nothing for safe_insync? if no SELinux support" do
                 sel_param.should = 'newcontext'
-                sel_param.expects(:selinux_support?).returns false
+                expect(sel_param).to receive(:selinux_support?).and_return(false)
                 expect(sel_param.safe_insync?('oldcontext')).to eq(true)
               end
             end

data/spec/unit/type/macauthorization_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 module Puppet::Util::Plist
@@ -7,19 +6,17 @@ end
 macauth_type = Puppet::Type.type(:macauthorization)
 
 describe Puppet::Type.type(:macauthorization), "when checking macauthorization objects" do
-
   before do
     authplist = {}
     authplist["rules"] = { "foorule" => "foo" }
     authplist["rights"] = { "fooright" => "foo" }
     provider_class = macauth_type.provider(macauth_type.providers[0])
-    Puppet::Util::Plist.stubs(:parse_plist).with("/etc/authorization").returns(authplist)
-    macauth_type.stubs(:defaultprovider).returns provider_class
+    allow(Puppet::Util::Plist).to receive(:parse_plist).with("/etc/authorization").and_return(authplist)
+    allow(macauth_type).to receive(:defaultprovider).and_return(provider_class)
     @resource = macauth_type.new(:name => 'foo')
   end
 
   describe "when validating attributes" do
-
     parameters = [:name,]
     properties = [:auth_type, :allow_root, :authenticate_user, :auth_class,
       :comment, :group, :k_of_n, :mechanisms, :rule,
@@ -44,11 +41,9 @@ describe Puppet::Type.type(:macauthorization), "when checking macauthorization o
         expect(macauth_type.attrclass(property).doc).to be_instance_of(String)
       end
     end
-
   end
 
   describe "when validating properties" do
-
     it "should have a default provider inheriting from Puppet::Provider" do
       expect(macauth_type.defaultprovider.ancestors).to be_include(Puppet::Provider)
     end
@@ -70,7 +65,6 @@ describe Puppet::Type.type(:macauthorization), "when checking macauthorization o
         macauth_type.new(:name => "foo", :ensure => :absent)
       }.not_to raise_error
     end
-
   end
 
   [:k_of_n, :timeout, :tries].each do |property|
@@ -80,11 +74,13 @@ describe Puppet::Type.type(:macauthorization), "when checking macauthorization o
         prop.should = "300"
         expect(prop.should).to eq(300)
       end
+
       it "should support integers as a value" do
         prop = macauth_type.attrclass(property).new(:resource => @resource)
         prop.should = 300
         expect(prop.should).to eq(300)
       end
+
       it "should raise an error for non-integer values" do
         prop = macauth_type.attrclass(property).new(:resource => @resource)
         expect { prop.should = "foo" }.to raise_error(Puppet::Error)
@@ -99,11 +95,13 @@ describe Puppet::Type.type(:macauthorization), "when checking macauthorization o
         prop.should = "false"
         expect(prop.should).to eq(:false)
       end
+
       it "should convert boolean-looking true strings into actual booleans" do
         prop = macauth_type.attrclass(property).new(:resource => @resource)
         prop.should = "true"
         expect(prop.should).to eq(:true)
       end
+
       it "should raise an error for non-boolean values" do
         prop = macauth_type.attrclass(property).new(:resource => @resource)
         expect { prop.should = "foo" }.to raise_error(Puppet::Error)

data/spec/unit/type/mailalias_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:mailalias) do
@@ -24,13 +23,13 @@ describe Puppet::Type.type(:mailalias) do
 
   it "should try and set the recipient when it does the sync" do
     expect(recipient_resource.retrieve_resource[:recipient]).to eq(:absent)
-    recipient_resource.property(:recipient).expects(:set).with(["yay"])
+    expect(recipient_resource.property(:recipient)).to receive(:set).with(["yay"])
     recipient_resource.property(:recipient).sync
   end
 
   it "should try and set the included file when it does the sync" do
     expect(file_resource.retrieve_resource[:file]).to eq(:absent)
-    file_resource.property(:file).expects(:set).with(tmpfile_path)
+    expect(file_resource.property(:file)).to receive(:set).with(tmpfile_path)
     file_resource.property(:file).sync
   end
 

data/spec/unit/type/maillist_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 maillist = Puppet::Type.type(:maillist)
@@ -7,12 +6,12 @@ describe maillist do
   before do
     @provider_class = Puppet::Type.type(:maillist).provider(:mailman)
 
-    @provider = stub 'provider', :class => @provider_class, :clear => nil
-    @provider.stubs(:respond_to).with(:aliases).returns(true)
+    @provider = double('provider', :class => @provider_class, :clear => nil)
+    allow(@provider).to receive(:respond_to).with(:aliases).and_return(true)
 
-    @provider_class.stubs(:new).returns(@provider)
+    allow(@provider_class).to receive(:new).and_return(@provider)
 
-    Puppet::Type.type(:maillist).stubs(:defaultprovider).returns(@provider_class)
+    allow(Puppet::Type.type(:maillist)).to receive(:defaultprovider).and_return(@provider_class)
 
     @maillist = Puppet::Type.type(:maillist).new( :name => 'test' )
 
@@ -24,18 +23,16 @@ describe maillist do
     # Mail List aliases are careful not to stomp on managed Mail Alias aliases
 
     # test1 is an unmanaged alias from /etc/aliases
-    Puppet::Type.type(:mailalias).provider(:aliases).stubs(:target_object).returns( StringIO.new("test1: root\n") )
+    allow(Puppet::Type.type(:mailalias).provider(:aliases)).to receive(:target_object).and_return(StringIO.new("test1: root\n"))
 
     # test2 is a managed alias from the manifest
     dupe = Puppet::Type.type(:mailalias).new( :name => 'test2' )
     @catalog.add_resource dupe
 
-    @provider.stubs(:aliases).returns({"test1" => 'this will get included', "test2" => 'this will dropped', "test3" => 'this will get included'})
+    allow(@provider).to receive(:aliases).and_return({"test1" => 'this will get included', "test2" => 'this will dropped', "test3" => 'this will get included'})
 
     generated = @maillist.generate
     expect(generated.map{ |x| x.name  }.sort).to eq(['test1', 'test3'])
     expect(generated.map{ |x| x.class }).to      eq([Puppet::Type::Mailalias, Puppet::Type::Mailalias])
-
   end
-
 end

data/spec/unit/type/mcx_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/type/mcx'
@@ -6,7 +5,6 @@ require 'puppet/type/mcx'
 mcx_type = Puppet::Type.type(:mcx)
 
 describe mcx_type, "when validating attributes" do
-
   properties = [:ensure, :content]
   parameters = [:name, :ds_type, :ds_name]
 
@@ -14,6 +12,7 @@ describe mcx_type, "when validating attributes" do
     it "should have a #{p} parameter" do
       expect(mcx_type.attrclass(p).ancestors).to be_include(Puppet::Parameter)
     end
+
     it "should have documentation for its #{p} parameter" do
       expect(mcx_type.attrclass(p).doc).to be_instance_of(String)
     end
@@ -23,6 +22,7 @@ describe mcx_type, "when validating attributes" do
     it "should have a #{p} property" do
       expect(mcx_type.attrclass(p).ancestors).to be_include(Puppet::Property)
     end
+
     it "should have documentation for its #{p} property" do
       expect(mcx_type.attrclass(p).doc).to be_instance_of(String)
     end
@@ -31,10 +31,9 @@ describe mcx_type, "when validating attributes" do
 end
 
 describe mcx_type, "default values" do
-
   before :each do
     provider_class = mcx_type.provider(mcx_type.providers[0])
-    mcx_type.stubs(:defaultprovider).returns provider_class
+    allow(mcx_type).to receive(:defaultprovider).and_return(provider_class)
   end
 
   it "should be nil for :ds_type" do
@@ -48,14 +47,12 @@ describe mcx_type, "default values" do
   it "should be nil for :content" do
     expect(mcx_type.new(:name => '/Foo/bar')[:content]).to be_nil
   end
-
 end
 
 describe mcx_type, "when validating properties" do
-
   before :each do
     provider_class = mcx_type.provider(mcx_type.providers[0])
-    mcx_type.stubs(:defaultprovider).returns provider_class
+    allow(mcx_type).to receive(:defaultprovider).and_return(provider_class)
   end
 
   it "should be able to create an instance" do
@@ -75,5 +72,4 @@ describe mcx_type, "when validating properties" do
       mcx_type.new(:name => "/Foo/bar", :ensure => :absent)
     }.not_to raise_error
   end
-
 end

data/spec/unit/type/mount_spec.rb

@@ -1,10 +1,8 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows? do
-
   before :each do
-    Puppet::Type.type(:mount).stubs(:defaultprovider).returns providerclass
+    allow(Puppet::Type.type(:mount)).to receive(:defaultprovider).and_return(providerclass)
   end
 
   let :providerclass do
@@ -64,7 +62,6 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
   end
 
   describe "when validating values" do
-
     describe "for name" do
       it "should allow full qualified paths" do
         expect(described_class.new(:name => "/mnt/foo")[:name]).to eq('/mnt/foo')
@@ -145,8 +142,8 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
     describe "for blockdevice" do
       before :each do
         # blockdevice is only used on Solaris
-        Facter.stubs(:value).with(:operatingsystem).returns 'Solaris'
-        Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+        allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
       end
 
       it "should support normal /dev/rdsk paths for blockdevice" do
@@ -229,20 +226,20 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       end
 
       it "should support - on Solaris" do
-        Facter.stubs(:value).with(:operatingsystem).returns 'Solaris'
-        Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+        allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
         expect { described_class.new(:name => "/foo", :ensure => :present, :pass => '-') }.to_not raise_error
       end
 
       it "should default to 0 on non Solaris" do
-        Facter.stubs(:value).with(:osfamily).returns nil
-        Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
+        allow(Facter).to receive(:value).with(:osfamily).and_return(nil)
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return('HP-UX')
         expect(described_class.new(:name => "/foo", :ensure => :present)[:pass]).to eq(0)
       end
 
       it "should default to - on Solaris" do
-        Facter.stubs(:value).with(:operatingsystem).returns 'Solaris'
-        Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+        allow(Facter).to receive(:value).with(:operatingsystem).and_return('Solaris')
+        allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
         expect(described_class.new(:name => "/foo", :ensure => :present)[:pass]).to eq('-')
       end
     end
@@ -301,15 +298,14 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
     end
   end
 
-
   describe "when changing the host" do
     def test_ensure_change(options)
       provider.set(:ensure => options[:from])
-      provider.expects(:create).times(options[:create] || 0)
-      provider.expects(:destroy).times(options[:destroy] || 0)
-      provider.expects(:mount).never
-      provider.expects(:unmount).times(options[:unmount] || 0)
-      ensureprop.stubs(:syncothers)
+      expect(provider).to receive(:create).exactly(options[:create] || 0).times()
+      expect(provider).to receive(:destroy).exactly((options[:destroy] || 0)).times()
+      expect(provider).not_to receive(:mount)
+      expect(provider).to receive(:unmount).exactly(options[:unmount] || 0).times()
+      allow(ensureprop).to receive(:syncothers)
       ensureprop.should = options[:to]
       ensureprop.sync
       expect(!!provider.property_hash[:needs_mount]).to eq(!!options[:mount])
@@ -359,7 +355,6 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       test_ensure_change(:from => :unmounted, :to => :mounted, :mount => 1)
     end
 
-
     it "should be in sync if it is :absent and should be :absent" do
       ensureprop.should = :absent
       expect(ensureprop.safe_insync?(:absent)).to eq(true)
@@ -400,7 +395,6 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       expect(ensureprop.safe_insync?(:mounted)).to eq(false)
     end
 
-
     it "should be out of sync if it is :unmounted and should be :absent" do
       ensureprop.should = :absent
       expect(ensureprop.safe_insync?(:unmounted)).to eq(false)
@@ -421,7 +415,6 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       expect(ensureprop.safe_insync?(:unmounted)).to eq(true)
     end
 
-
     it "should be out of sync if it is :ghost and should be :absent" do
       ensureprop.should = :absent
       expect(ensureprop.safe_insync?(:ghost)).to eq(false)
@@ -447,35 +440,35 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
     pending "2.6.x specifies slightly different behavior and the desired behavior needs to be clarified and revisited.  See ticket #4904" do
       it "should remount if it is supposed to be mounted" do
         resource[:ensure] = "mounted"
-        provider.expects(:remount)
+        expect(provider).to receive(:remount)
 
         resource.refresh
       end
 
       it "should not remount if it is supposed to be present" do
         resource[:ensure] = "present"
-        provider.expects(:remount).never
+        expect(provider).not_to receive(:remount)
 
         resource.refresh
       end
 
       it "should not remount if it is supposed to be absent" do
         resource[:ensure] = "absent"
-        provider.expects(:remount).never
+        expect(provider).not_to receive(:remount)
 
         resource.refresh
       end
 
       it "should not remount if it is supposed to be defined" do
         resource[:ensure] = "defined"
-        provider.expects(:remount).never
+        expect(provider).not_to receive(:remount)
 
         resource.refresh
       end
 
       it "should not remount if it is supposed to be unmounted" do
         resource[:ensure] = "unmounted"
-        provider.expects(:remount).never
+        expect(provider).not_to receive(:remount)
 
         resource.refresh
       end
@@ -483,7 +476,7 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       it "should not remount swap filesystems" do
         resource[:ensure] = "mounted"
         resource[:fstype] = "swap"
-        provider.expects(:remount).never
+        expect(provider).not_to receive(:remount)
 
         resource.refresh
       end
@@ -491,7 +484,6 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
   end
 
   describe "when modifying an existing mount entry" do
-
     let :initial_values do
       {
         :ensure      => :mounted,
@@ -506,7 +498,6 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       }
     end
 
-
     let :resource do
       described_class.new(initial_values.merge(:provider => provider))
     end
@@ -516,14 +507,14 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
     end
 
     def run_in_catalog(*resources)
-      Puppet::Util::Storage.stubs(:store)
+      allow(Puppet::Util::Storage).to receive(:store)
       catalog = Puppet::Resource::Catalog.new
       catalog.add_resource(*resources)
       catalog.apply
     end
 
     it "should use the provider to change the dump value" do
-      provider.expects(:dump=).with(1)
+      expect(provider).to receive(:dump=).with(1)
 
       resource[:dump] = 1
 
@@ -531,12 +522,10 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
     end
 
     it "should umount before flushing changes to disk" do
-      syncorder = sequence('syncorder')
-
-      provider.expects(:unmount).in_sequence(syncorder)
-      provider.expects(:options=).in_sequence(syncorder).with 'hard'
-      resource.expects(:flush).in_sequence(syncorder) # Call inside syncothers
-      resource.expects(:flush).in_sequence(syncorder) # I guess transaction or anything calls flush again
+      expect(provider).to receive(:unmount).ordered()
+      expect(provider).to receive(:options=).ordered().with('hard')
+      expect(resource).to receive(:flush).ordered() # Call inside syncothers
+      expect(resource).to receive(:flush).ordered() # I guess transaction or anything calls flush again
 
       resource[:ensure] = :unmounted
       resource[:options] = 'hard'
@@ -546,7 +535,6 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
   end
 
   describe "establishing autorequires and autobefores" do
-
     def create_mount_resource(path)
       described_class.new(
         :name => path,