From 10021e652686d1687470145e789968fa673f0c93 Mon Sep 17 00:00:00 2001 From: Balasankar C Date: Fri, 4 Sep 2015 11:19:10 +0530 Subject: [PATCH 1/2] Port tests to RSpec 3 --- spec/settingslogic_spec.rb | 112 ++++++++++++++++++------------------- 1 file changed, 56 insertions(+), 56 deletions(-) diff --git a/spec/settingslogic_spec.rb b/spec/settingslogic_spec.rb index 34e4798..36bf450 100644 --- a/spec/settingslogic_spec.rb +++ b/spec/settingslogic_spec.rb @@ -2,50 +2,50 @@ describe "Settingslogic" do it "should access settings" do - Settings.setting2.should == 5 + expect(Settings.setting2).to eq(5) end it "should access nested settings" do - Settings.setting1.setting1_child.should == "saweet" + expect(Settings.setting1.setting1_child).to eq("saweet") end it "should access settings in nested arrays" do - Settings.array.first.name.should == "first" + expect(Settings.array.first.name).to eq("first") end it "should access deep nested settings" do - Settings.setting1.deep.another.should == "my value" + expect(Settings.setting1.deep.another).to eq("my value") end it "should access extra deep nested settings" do - Settings.setting1.deep.child.value.should == 2 + expect(Settings.setting1.deep.child.value).to eq(2) end it "should enable erb" do - Settings.setting3.should == 25 + expect(Settings.setting3).to eq(25) end it "should namespace settings" do - Settings2.setting1_child.should == "saweet" - Settings2.deep.another.should == "my value" + expect(Settings2.setting1_child).to eq("saweet") + expect(Settings2.deep.another).to eq("my value") end it "should return the namespace" do - Settings.namespace.should be_nil - Settings2.namespace.should == 'setting1' + expect(Settings.namespace).to be_nil + expect(Settings2.namespace).to eq('setting1') end it "should distinguish nested keys" do - Settings.language.haskell.paradigm.should == 'functional' - Settings.language.smalltalk.paradigm.should == 'object oriented' + expect(Settings.language.haskell.paradigm).to eq('functional') + expect(Settings.language.smalltalk.paradigm).to eq('object oriented') end it "should not collide with global methods" do - Settings3.nested.collides.does.should == 'not either' + expect(Settings3.nested.collides.does).to eq('not either') Settings3[:nested] = 'fooey' - Settings3[:nested].should == 'fooey' - Settings3.nested.should == 'fooey' - Settings3.collides.does.should == 'not' + expect(Settings3[:nested]).to eq('fooey') + expect(Settings3.nested).to eq('fooey') + expect(Settings3.collides.does).to eq('not') end it "should raise a helpful error message" do @@ -53,19 +53,19 @@ begin Settings.missing rescue => e - e.should be_kind_of Settingslogic::MissingSetting + expect(e).to be_kind_of Settingslogic::MissingSetting end - e.should_not be_nil - e.message.should =~ /Missing setting 'missing' in/ + expect(e).not_to be_nil + expect(e.message).to match(/Missing setting 'missing' in/) e = nil begin Settings.language.missing rescue => e - e.should be_kind_of Settingslogic::MissingSetting + expect(e).to be_kind_of Settingslogic::MissingSetting end - e.should_not be_nil - e.message.should =~ /Missing setting 'missing' in 'language' section/ + expect(e).not_to be_nil + expect(e.message).to match(/Missing setting 'missing' in 'language' section/) end it "should handle optional / dynamic settings" do @@ -73,31 +73,31 @@ begin Settings.language.erlang rescue => e - e.should be_kind_of Settingslogic::MissingSetting + expect(e).to be_kind_of Settingslogic::MissingSetting end - e.should_not be_nil - e.message.should =~ /Missing setting 'erlang' in 'language' section/ + expect(e).not_to be_nil + expect(e.message).to match(/Missing setting 'erlang' in 'language' section/) - Settings.language['erlang'].should be_nil + expect(Settings.language['erlang']).to be_nil Settings.language['erlang'] = 5 - Settings.language['erlang'].should == 5 + expect(Settings.language['erlang']).to eq(5) Settings.language['erlang'] = {'paradigm' => 'functional'} - Settings.language.erlang.paradigm.should == 'functional' - Settings.respond_to?('erlang').should be_false + expect(Settings.language.erlang.paradigm).to eq('functional') + expect(Settings.respond_to?('erlang')).to be_falsey Settings.reload! - Settings.language['erlang'].should be_nil + expect(Settings.language['erlang']).to be_nil Settings.language[:erlang] ||= 5 - Settings.language[:erlang].should == 5 + expect(Settings.language[:erlang]).to eq(5) Settings.language[:erlang] = {} Settings.language[:erlang][:paradigm] = 'functional' - Settings.language.erlang.paradigm.should == 'functional' + expect(Settings.language.erlang.paradigm).to eq('functional') Settings[:toplevel] = '42' - Settings.toplevel.should == '42' + expect(Settings.toplevel).to eq('42') end it "should raise an error on a nil source argument" do @@ -106,13 +106,13 @@ class NoSource < Settingslogic; end begin NoSource.foo.bar rescue => e - e.should be_kind_of Errno::ENOENT + expect(e).to be_kind_of Errno::ENOENT end - e.should_not be_nil + expect(e).not_to be_nil end it "should allow suppressing errors" do - Settings4.non_existent_key.should be_nil + expect(Settings4.non_existent_key).to be_nil end # This one edge case currently does not pass, because it requires very @@ -127,80 +127,80 @@ class NoSource < Settingslogic; end it "should handle oddly-named settings" do Settings.language['some-dash-setting#'] = 'dashtastic' - Settings.language['some-dash-setting#'].should == 'dashtastic' + expect(Settings.language['some-dash-setting#']).to eq('dashtastic') end it "should handle settings with nil value" do Settings["flag"] = true Settings["flag"] = nil - Settings.flag.should == nil + expect(Settings.flag).to eq(nil) end it "should handle settings with false value" do Settings["flag"] = true Settings["flag"] = false - Settings.flag.should == false + expect(Settings.flag).to eq(false) end it "should support instance usage as well" do settings = SettingsInst.new(Settings.source) - settings.setting1.setting1_child.should == "saweet" + expect(settings.setting1.setting1_child).to eq("saweet") end it "should be able to get() a key with dot.notation" do - Settings.get('setting1.setting1_child').should == "saweet" - Settings.get('setting1.deep.another').should == "my value" - Settings.get('setting1.deep.child.value').should == 2 + expect(Settings.get('setting1.setting1_child')).to eq("saweet") + expect(Settings.get('setting1.deep.another')).to eq("my value") + expect(Settings.get('setting1.deep.child.value')).to eq(2) end # If .name is not a property, delegate to superclass it "should respond with Module.name" do - Settings2.name.should == "Settings2" + expect(Settings2.name).to eq("Settings2") end # If .name is called on Settingslogic itself, handle appropriately # by delegating to Hash it "should have the parent class always respond with Module.name" do - Settingslogic.name.should == 'Settingslogic' + expect(Settingslogic.name).to eq('Settingslogic') end # If .name is a property, respond with that instead of delegating to superclass it "should allow a name setting to be overriden" do - Settings.name.should == 'test' + expect(Settings.name).to eq('test') end it "should allow symbolize_keys" do Settings.reload! result = Settings.language.haskell.symbolize_keys - result.class.should == Hash - result.should == {:paradigm => "functional"} + expect(result.class).to eq(Hash) + expect(result).to eq({:paradigm => "functional"}) end it "should allow symbolize_keys on nested hashes" do Settings.reload! result = Settings.language.symbolize_keys - result.class.should == Hash - result.should == { + expect(result.class).to eq(Hash) + expect(result).to eq({ :haskell => {:paradigm => "functional"}, :smalltalk => {:paradigm => "object oriented"} - } + }) end it "should handle empty file" do - SettingsEmpty.keys.should eql([]) + expect(SettingsEmpty.keys).to eql([]) end # Put this test last or else call to .instance will load @instance, # masking bugs. it "should be a hash" do - Settings.send(:instance).should be_is_a(Hash) + expect(Settings.send(:instance)).to be_is_a(Hash) end describe "#to_hash" do it "should return a new instance of a Hash object" do - Settings.to_hash.should be_kind_of(Hash) - Settings.to_hash.class.name.should == "Hash" - Settings.to_hash.object_id.should_not == Settings.object_id + expect(Settings.to_hash).to be_kind_of(Hash) + expect(Settings.to_hash.class.name).to eq("Hash") + expect(Settings.to_hash.object_id).not_to eq(Settings.object_id) end end From 33638fd5c034d645f1866107267d5d1220ce41b9 Mon Sep 17 00:00:00 2001 From: Balasankar C Date: Fri, 4 Sep 2015 11:19:18 +0530 Subject: [PATCH 2/2] Update gems --- Gemfile.lock | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/Gemfile.lock b/Gemfile.lock index d2bea64..0af7521 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -6,16 +6,21 @@ PATH GEM remote: https://rubygems.org/ specs: - diff-lcs (1.1.3) - rake (10.0.3) - rspec (2.12.0) - rspec-core (~> 2.12.0) - rspec-expectations (~> 2.12.0) - rspec-mocks (~> 2.12.0) - rspec-core (2.12.2) - rspec-expectations (2.12.1) - diff-lcs (~> 1.1.3) - rspec-mocks (2.12.1) + diff-lcs (1.2.5) + rake (10.4.2) + rspec (3.3.0) + rspec-core (~> 3.3.0) + rspec-expectations (~> 3.3.0) + rspec-mocks (~> 3.3.0) + rspec-core (3.3.2) + rspec-support (~> 3.3.0) + rspec-expectations (3.3.1) + diff-lcs (>= 1.2.0, < 2.0) + rspec-support (~> 3.3.0) + rspec-mocks (3.3.2) + diff-lcs (>= 1.2.0, < 2.0) + rspec-support (~> 3.3.0) + rspec-support (3.3.0) PLATFORMS ruby @@ -24,3 +29,6 @@ DEPENDENCIES rake rspec settingslogic! + +BUNDLED WITH + 1.10.6