pump 0.6.6 → 0.7.0

data/spec/pump/json_spec.rb

@@ -6,12 +6,12 @@ describe Pump::Json do
     let(:json) { Pump::Json.new('person', [{:name => :name}]) }
 
     it "requires one object" do
-      lambda{ json.encode }.should raise_error(ArgumentError)
-      lambda{ json.encode(person) }.should_not raise_error
+      expect{ json.encode }.to raise_error(ArgumentError)
+      expect{ json.encode(person) }.not_to raise_error
     end
 
     it "returns json string" do
-      json.encode(person).should eql("{\"person\":{\"name\":\"Benny\"}}")
+      expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Benny\"}}")
     end
 
     context "with time object" do
@@ -19,7 +19,7 @@ describe Pump::Json do
       let(:json) { Pump::Json.new('person', [{:born => :born}]) }
 
       it "formats time as iso string" do
-        json.encode(person).should eql("{\"person\":{\"born\":\"2007-11-01T15:25:00+09:00\"}}")
+        expect(json.encode(person)).to eql("{\"person\":{\"born\":\"2007-11-01T15:25:00+09:00\"}}")
       end
     end
 
@@ -28,7 +28,7 @@ describe Pump::Json do
       let(:json) { Pump::Json.new('person', [{:born => :born}]) }
 
       it "formats time as iso string" do
-        json.encode(person).should eql("{\"person\":{\"born\":\"2007-11-01\"}}")
+        expect(json.encode(person)).to eql("{\"person\":{\"born\":\"2007-11-01\"}}")
       end
     end
 
@@ -37,7 +37,7 @@ describe Pump::Json do
       let(:json) { Pump::Json.new('person', [{:born => :born}]) }
 
       it "formats time as iso string" do
-        json.encode(person).should eql("{\"person\":{\"born\":\"2007-11-01T15:25:00+09:00\"}}")
+        expect(json.encode(person)).to eql("{\"person\":{\"born\":\"2007-11-01T15:25:00+09:00\"}}")
       end
     end
 
@@ -47,7 +47,7 @@ describe Pump::Json do
         let(:people) { [person] }
 
         it "returns json string" do
-          json.encode(people).should eql("[{\"person\":{\"name\":\"Benny\"}}]")
+          expect(json.encode(people)).to eql("[{\"person\":{\"name\":\"Benny\"}}]")
         end
       end
 
@@ -55,12 +55,12 @@ describe Pump::Json do
         let(:people) { [person, Struct.new(:name, :age).new('Carlo', 5)] }
 
         it "returns xml string" do
-          json.encode(people).should eql("[{\"person\":{\"name\":\"Benny\"}},{\"person\":{\"name\":\"Carlo\"}}]")
+          expect(json.encode(people)).to eql("[{\"person\":{\"name\":\"Benny\"}},{\"person\":{\"name\":\"Carlo\"}}]")
         end
 
         context "with exclude_root_in_json option" do
           it "returns json string without root" do
-            json.encode(people, :exclude_root_in_json => true).should eql("[{\"name\":\"Benny\"},{\"name\":\"Carlo\"}]")
+            expect(json.encode(people, :exclude_root_in_json => true)).to eql("[{\"name\":\"Benny\"},{\"name\":\"Carlo\"}]")
           end
         end
       end
@@ -69,7 +69,7 @@ describe Pump::Json do
         let(:people) { [] }
 
         it "returns xml string" do
-          json.encode(people).should eql("[]")
+          expect(json.encode(people)).to eql("[]")
         end
       end
     end
@@ -78,7 +78,7 @@ describe Pump::Json do
       let(:person) { Struct.new(:name, :age).new('', 9) }
 
       it do
-        json.encode(person).should eql("{\"person\":{\"name\":\"\"}}")
+        expect(json.encode(person)).to eql("{\"person\":{\"name\":\"\"}}")
       end
     end
 
@@ -86,7 +86,7 @@ describe Pump::Json do
       let(:person) { Struct.new(:name, :age).new(nil, 9) }
 
       it do
-        json.encode(person).should eql("{\"person\":{\"name\":null}}")
+        expect(json.encode(person)).to eql("{\"person\":{\"name\":null}}")
       end
     end
 
@@ -97,7 +97,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :if => :is_young}]) }
 
         it "skips key-value on false" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\"}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Gorbatschow\"}}")
         end
       end
 
@@ -105,7 +105,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :unless => :is_old}]) }
 
         it "skips key-value on false" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\"}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Gorbatschow\"}}")
         end
       end
 
@@ -114,7 +114,7 @@ describe Pump::Json do
         let(:people) { [person, Struct.new(:name, :age).new('Schewardnadse', nil)] }
 
         it "skips key-value on false" do
-          json.encode(people).should eql("[{\"person\":{\"name\":\"Gorbatschow\",\"age\":82}},{\"person\":{\"name\":\"Schewardnadse\"}}]")
+          expect(json.encode(people)).to eql("[{\"person\":{\"name\":\"Gorbatschow\",\"age\":82}},{\"person\":{\"name\":\"Schewardnadse\"}}]")
         end
       end
     end
@@ -126,7 +126,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :static_value => 12}]) }
 
         it "returns given static_value" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\",\"age\":12}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Gorbatschow\",\"age\":12}}")
         end
       end
 
@@ -134,7 +134,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :static_value => nil}]) }
 
         it "returns given static_value" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\",\"age\":null}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Gorbatschow\",\"age\":null}}")
         end
       end
 
@@ -142,7 +142,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :static_value => 12, :if => :is_yount}]) }
 
         it "returns given static_value" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\"}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Gorbatschow\"}}")
         end
       end
 
@@ -150,7 +150,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age, :static_value => 12, :unless => :is_yount}]) }
 
         it "returns given static_value" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Gorbatschow\",\"age\":12}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Gorbatschow\",\"age\":12}}")
         end
       end
     end
@@ -159,14 +159,14 @@ describe Pump::Json do
       let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}]}]) }
 
       it "returns static string" do
-        json.encode(person).should eql("{\"person\":{\"name\":\"Benny\",\"parent\":{\"name\":\"Benny\",\"age\":9}}}")
+        expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Benny\",\"parent\":{\"name\":\"Benny\",\"age\":9}}}")
       end
 
       context "with static_value = nil" do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}], :static_value => nil}]) }
 
         it "uses static value" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Benny\",\"parent\":null}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Benny\",\"parent\":null}}")
         end
       end
 
@@ -174,7 +174,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:parent => [{:name => :name}, {:age => :age}], :static_value => {}}]) }
 
         it "uses static value" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Benny\",\"parent\":{}}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Benny\",\"parent\":{}}}")
         end
       end
     end
@@ -190,14 +190,14 @@ describe Pump::Json do
                                             :array => [{:name => :name}]}]) }
 
       it "returns json string" do
-        json.encode(person).should eql("{\"person\":{\"name\":\"Gustav\",\"children\":[{\"name\":\"Lilly\"},{\"name\":\"Lena\"}]}}")
+        expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Gustav\",\"children\":[{\"name\":\"Lilly\"},{\"name\":\"Lena\"}]}}")
       end
 
       context "with static_value = nil" do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:children => :children,
                                             :array => [{:name => :name}], :static_value => nil}]) }
         it "uses static value" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Gustav\",\"children\":[]}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Gustav\",\"children\":[]}}")
         end
       end
 
@@ -205,7 +205,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:children => :children,
                                             :array => [{:name => :name}], :static_value => []}]) }
         it "uses static value" do
-          json.encode(person).should eql("{\"person\":{\"name\":\"Gustav\",\"children\":[]}}")
+          expect(json.encode(person)).to eql("{\"person\":{\"name\":\"Gustav\",\"children\":[]}}")
         end
       end
     end
@@ -215,7 +215,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('my-person', [{"first-name" => :name}]) }
 
         it "returns json string with underscores" do
-          json.encode(person).should eql("{\"my_person\":{\"first_name\":\"Benny\"}}")
+          expect(json.encode(person)).to eql("{\"my_person\":{\"first_name\":\"Benny\"}}")
         end
       end
 
@@ -223,7 +223,7 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('my-person', [{"first-name" => :name}], :json_key_style => :dashes) }
 
         it "returns json string with dashes" do
-          json.encode(person).should eql("{\"my-person\":{\"first-name\":\"Benny\"}}")
+          expect(json.encode(person)).to eql("{\"my-person\":{\"first-name\":\"Benny\"}}")
         end
       end
 
@@ -231,18 +231,18 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('my-person', [{"first-name" => :name}], :json_key_style => :underscores) }
 
         it "returns json string with underscores" do
-          json.encode(person).should eql("{\"my_person\":{\"first_name\":\"Benny\"}}")
+          expect(json.encode(person)).to eql("{\"my_person\":{\"first_name\":\"Benny\"}}")
         end
       end
     end
 
     context "with :exclude_root_in_json option" do
       it "returns json string without root" do
-        json.encode(person, :exclude_root_in_json => true).should eql("{\"name\":\"Benny\"}")
+        expect(json.encode(person, :exclude_root_in_json => true)).to eql("{\"name\":\"Benny\"}")
       end
 
       it "returns json string without root on array" do
-        json.encode([person], :exclude_root_in_json => true).should eql("[{\"name\":\"Benny\"}]")
+        expect(json.encode([person], :exclude_root_in_json => true)).to eql("[{\"name\":\"Benny\"}]")
       end
     end
 
@@ -253,23 +253,23 @@ describe Pump::Json do
       ])}
 
       it "returns only specified fields" do
-        json.encode(person, :fields => ['name']).should eql("{\"person\":{\"name\":\"Benny\"}}")
-        json.encode(person, :fields => ['age']).should eql("{\"person\":{\"age\":9}}")
+        expect(json.encode(person, :fields => ['name'])).to eql("{\"person\":{\"name\":\"Benny\"}}")
+        expect(json.encode(person, :fields => ['age'])).to eql("{\"person\":{\"age\":9}}")
       end
 
       it "ignores unknown fields" do
-        json.encode(person, :fields => ['name', 'unknown']).should eql("{\"person\":{\"name\":\"Benny\"}}")
-        json.encode(person, :fields => ['unknown']).should eql("{\"person\":{}}")
+        expect(json.encode(person, :fields => ['name', 'unknown'])).to eql("{\"person\":{\"name\":\"Benny\"}}")
+        expect(json.encode(person, :fields => ['unknown'])).to eql("{\"person\":{}}")
       end
 
       it "accepts dasherized and underscored field names" do
-        json.encode(person, :fields => ['name', 'last-name']).should eql("{\"person\":{\"name\":\"Benny\",\"last_name\":\"Hellman\"}}")
-        json.encode(person, :fields => ['name', 'last_name']).should eql("{\"person\":{\"name\":\"Benny\",\"last_name\":\"Hellman\"}}")
+        expect(json.encode(person, :fields => ['name', 'last-name'])).to eql("{\"person\":{\"name\":\"Benny\",\"last_name\":\"Hellman\"}}")
+        expect(json.encode(person, :fields => ['name', 'last_name'])).to eql("{\"person\":{\"name\":\"Benny\",\"last_name\":\"Hellman\"}}")
       end
 
       context "deep hash-like nesting" do
         it "adds all keys if fields contains parent" do
-          json.encode(person, :fields => ['name', 'parent']).should eql(
+          expect(json.encode(person, :fields => ['name', 'parent'])).to eql(
             "{\"person\":{\"name\":\"Benny\",\"parent\":{\"name\":\"Benny\",\"age\":9}}}"
           )
         end
@@ -286,7 +286,7 @@ describe Pump::Json do
                                               :array => [{:name => :name}, {:age => :age}]}]) }
 
         it "adds all keys if fields contains children" do
-          json.encode(person, :fields => ['name', 'children']).should eql(
+          expect(json.encode(person, :fields => ['name', 'children'])).to eql(
             "{\"person\":{\"name\":\"Gustav\",\"children\":[{\"name\":\"Lilly\",\"age\":2},{\"name\":\"Lena\",\"age\":3}]}}"
           )
         end
@@ -303,9 +303,9 @@ describe Pump::Json do
         let(:json) { Pump::Json.new('person', [{:name => :name}, {:age => :age}]) }
 
         it "returns only specified fields" do
-          json.encode(people, :fields => ['name']).should eql("[{\"person\":{\"name\":\"Gustav\"}},{\"person\":{\"name\":\"Mary\"}}]")
+          expect(json.encode(people, :fields => ['name'])).to eql("[{\"person\":{\"name\":\"Gustav\"}},{\"person\":{\"name\":\"Mary\"}}]")
         end
       end
     end
   end
-end
+end

data/spec/pump/object_spec.rb

@@ -75,31 +75,31 @@ end
 
 describe Pump::Object do
   it "should not extend all objects by default" do
-    ObjectWithoutInclude.respond_to?(:pumps).should eql(false)
+    expect(ObjectWithoutInclude.respond_to?(:pumps)).to eql(false)
   end
 
   context "when included" do
     subject { ObjectWithInclude }
 
     it "should add pumps class method" do
-      subject.respond_to?(:pumps).should eql(true)
-      subject.pumps.size.should eql(0)
+      expect(subject.respond_to?(:pumps)).to eql(true)
+      expect(subject.pumps.size).to eql(0)
     end
 
     it "should add pump_to_xml instance method" do
-      subject.new.respond_to?(:pump_to_xml).should eql(true)
+      expect(subject.new.respond_to?(:pump_to_xml)).to eql(true)
     end
 
     it "should add pump_to_json instance method" do
-      subject.new.respond_to?(:pump_to_json).should eql(true)
+      expect(subject.new.respond_to?(:pump_to_json)).to eql(true)
     end
 
     it "should fall back to original to_xml on pump_to_xml" do
-      subject.new.pump_to_xml.should eql("<to_xml />")
+      expect(subject.new.pump_to_xml).to eql("<to_xml />")
     end
 
     it "should fall back to original to_json on pump_to_xml" do
-      subject.new.pump_to_json.should eql("{to_json}")
+      expect(subject.new.pump_to_json).to eql("{to_json}")
     end
   end
 
@@ -107,19 +107,19 @@ describe Pump::Object do
     subject { ObjectWithIncludeAndPumps }
 
     it "should add pump" do
-      subject.pumps.size.should eql(1)
+      expect(subject.pumps.size).to eql(1)
     end
 
     it "should return xml on pump_to_xml" do
-      subject.new.pump_to_xml.should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n</my-object>\n")
+      expect(subject.new.pump_to_xml).to eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n</my-object>\n")
     end
 
     it "should return json on pump_to_json" do
-      subject.new.pump_to_json.should eql("{\"my_object\":{\"name\":\"MyName\"}}")
+      expect(subject.new.pump_to_json).to eql("{\"my_object\":{\"name\":\"MyName\"}}")
     end
 
     it "should pass down options to encoder" do
-      subject.new.pump_to_json(:exclude_root_in_json => true).should eql("{\"name\":\"MyName\"}")
+      expect(subject.new.pump_to_json(:exclude_root_in_json => true)).to eql("{\"name\":\"MyName\"}")
     end
   end
 
@@ -127,31 +127,31 @@ describe Pump::Object do
     subject { ObjectWithIncludeAndMultiplePumps }
 
     it "should add pumps" do
-      subject.pumps.size.should eql(2)
+      expect(subject.pumps.size).to eql(2)
     end
 
     it "should return default xml on pump_to_xml" do
-      subject.new.pump_to_xml.should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n</my-object>\n")
+      expect(subject.new.pump_to_xml).to eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n</my-object>\n")
     end
 
     it "should return special xml on set option" do
-      subject.new.pump_to_xml(:set => :sometimes).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n  <age type=\"integer\">72</age>\n</my-object>\n")
+      expect(subject.new.pump_to_xml(:set => :sometimes)).to eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n  <age type=\"integer\">72</age>\n</my-object>\n")
     end
 
     it "should return default xml on pump_to_xml with unknown set option" do
-      subject.new.pump_to_xml(:set => :unknown).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n</my-object>\n")
+      expect(subject.new.pump_to_xml(:set => :unknown)).to eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n</my-object>\n")
     end
 
     it "should return default json on pump_to_json" do
-      subject.new.pump_to_json.should eql("{\"my_object\":{\"name\":\"MyName\"}}")
+      expect(subject.new.pump_to_json).to eql("{\"my_object\":{\"name\":\"MyName\"}}")
     end
 
     it "should return special json on set option" do
-      subject.new.pump_to_json(:set => :sometimes).should eql("{\"my_object\":{\"name\":\"MyName\",\"age\":72}}")
+      expect(subject.new.pump_to_json(:set => :sometimes)).to eql("{\"my_object\":{\"name\":\"MyName\",\"age\":72}}")
     end
 
     it "should return default json on pump_to_json with unknown set option" do
-      subject.new.pump_to_json(:set => :unknown).should eql("{\"my_object\":{\"name\":\"MyName\"}}")
+      expect(subject.new.pump_to_json(:set => :unknown)).to eql("{\"my_object\":{\"name\":\"MyName\"}}")
     end
   end
 
@@ -159,23 +159,23 @@ describe Pump::Object do
     subject { ObjectWithIncludeAndMultiplePumpsWithInheritance }
 
     it "should add pumps" do
-      subject.pumps.size.should eql(2)
+      expect(subject.pumps.size).to eql(2)
     end
 
     it "should return default xml on pump_to_xml" do
-      subject.new.pump_to_xml.should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n  <role>my_role</role>\n</my-object>\n")
+      expect(subject.new.pump_to_xml).to eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n  <role>my_role</role>\n</my-object>\n")
     end
 
     it "should return default json on pump_to_json" do
-      subject.new.pump_to_json.should eql("{\"my_object\":{\"name\":\"MyName\",\"role\":\"my_role\"}}")
+      expect(subject.new.pump_to_json).to eql("{\"my_object\":{\"name\":\"MyName\",\"role\":\"my_role\"}}")
     end
 
     it "should return special inherited xml on pump_to_xml(:set => :restricted)" do
-      subject.new.pump_to_xml(:set => :restricted).should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n  <role>basic_role</role>\n  <age type=\"integer\">72</age>\n</my-object>\n")
+      expect(subject.new.pump_to_xml(:set => :restricted)).to eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<my-object>\n  <name>MyName</name>\n  <role>basic_role</role>\n  <age type=\"integer\">72</age>\n</my-object>\n")
     end
 
     it "should return special inherited json on pump_to_json(:set => :restricted)" do
-      subject.new.pump_to_json(:set => :restricted).should eql("{\"my_object\":{\"name\":\"MyName\",\"role\":\"basic_role\",\"age\":72}}")
+      expect(subject.new.pump_to_json(:set => :restricted)).to eql("{\"my_object\":{\"name\":\"MyName\",\"role\":\"basic_role\",\"age\":72}}")
     end
   end
 end

data/spec/pump/xml/tag_array_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe Pump::Xml::TagArray do
   describe ".new" do
     it "requires one parameter" do
-      lambda{ Pump::Xml::TagArray.new }.should raise_error(ArgumentError)
-      lambda{ Pump::Xml::TagArray.new('tag') }.should_not raise_error
+      expect{ Pump::Xml::TagArray.new }.to raise_error(ArgumentError)
+      expect{ Pump::Xml::TagArray.new('tag') }.not_to raise_error
     end
   end
 end

data/spec/pump/xml/tag_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe Pump::Xml::Tag do
   describe ".new" do
     it "requires one parameter" do
-      lambda{ Pump::Xml::Tag.new }.should raise_error(ArgumentError)
-      lambda{ Pump::Xml::Tag.new(0) }.should_not raise_error
+      expect{ Pump::Xml::Tag.new }.to raise_error(ArgumentError)
+      expect{ Pump::Xml::Tag.new(0) }.not_to raise_error
     end
   end
 end

data/spec/pump/xml/value_spec.rb

@@ -5,8 +5,8 @@ describe Pump::Xml::Value do
 
   describe ".new" do
     it "requires one parameter" do
-      lambda{ Pump::Xml::Value.new }.should raise_error(ArgumentError)
-      lambda{ subject }.should_not raise_error
+      expect{ Pump::Xml::Value.new }.to raise_error(ArgumentError)
+      expect{ subject }.not_to raise_error
     end
   end
 
@@ -31,7 +31,7 @@ describe Pump::Xml::Value do
 
     context "with path name" do
       it do
-        subject.to_s('custom_path').should eql("\#{remove_ilegal_chars custom_path.to_s.encode(:xml => :text)}")
+        expect(subject.to_s('custom_path')).to eql("\#{remove_ilegal_chars custom_path.to_s.encode(:xml => :text)}")
       end
     end
   end