nori-ng-1.6 2.3.0

data/spec/nori/api_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+
+describe Nori do
+
+  describe "PARSERS" do
+    it "should return a Hash of parser details" do
+      Nori::PARSERS.should == { :rexml => "REXML", :nokogiri => "Nokogiri" }
+    end
+  end
+
+  context ".new" do
+    it "defaults to not strip any namespace identifiers" do
+      xml = <<-XML
+        <history xmlns:ns10="http://ns10.example.com">
+          <ns10:case>a_case</ns10:case>
+        </history>
+      XML
+
+      nori.parse(xml)["history"]["ns10:case"].should == "a_case"
+    end
+
+    it "defaults to not change XML tags" do
+      xml = '<userResponse id="1"><accountStatus>active</accountStatus></userResponse>'
+      nori.parse(xml).should == { "userResponse" => { "@id" => "1", "accountStatus" => "active" } }
+    end
+
+    it "raises when passed unknown global options" do
+      expect { Nori.new(:invalid => true) }.
+        to raise_error(ArgumentError, /Spurious options: \[:invalid\]/)
+    end
+  end
+
+  context ".new with :strip_namespaces" do
+    it "strips the namespace identifiers when set to true" do
+      xml = '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"></soap:Envelope>'
+      nori(:strip_namespaces => true).parse(xml).should have_key("Envelope")
+    end
+
+    it "still converts namespaced entries to array elements" do
+      xml = <<-XML
+        <history
+            xmlns:ns10="http://ns10.example.com"
+            xmlns:ns11="http://ns10.example.com">
+          <ns10:case><ns10:name>a_name</ns10:name></ns10:case>
+          <ns11:case><ns11:name>another_name</ns11:name></ns11:case>
+        </history>
+      XML
+
+      expected = [{ "name" => "a_name" }, { "name" => "another_name" }]
+      nori(:strip_namespaces => true).parse(xml)["history"]["case"].should == expected
+    end
+  end
+
+  context ".new with :convert_tags_to" do
+    it "converts all tags by a given formula" do
+      xml = '<userResponse id="1"><accountStatus>active</accountStatus></userResponse>'
+
+      snakecase_symbols = lambda { |tag| tag.snakecase.to_sym }
+      nori = nori(:convert_tags_to => snakecase_symbols)
+
+      nori.parse(xml).should == { :user_response => { :@id => "1", :account_status => "active" } }
+    end
+  end
+
+	context '#find' do
+		before do
+      upcase = lambda { |tag| tag.upcase }
+			@nori = nori(:convert_tags_to => upcase)
+
+      xml = '<userResponse id="1"><accountStatus>active</accountStatus></userResponse>'
+			@hash = @nori.parse(xml)
+		end
+
+		it 'returns the Hash when the path is empty' do
+			result = @nori.find(@hash)
+			expect(result).to eq("USERRESPONSE" => { "ACCOUNTSTATUS" => "active", "@ID" => "1" })
+		end
+
+		it 'returns the result for a single key' do
+			result = @nori.find(@hash, 'userResponse')
+			expect(result).to eq("ACCOUNTSTATUS" => "active", "@ID" => "1")
+		end
+
+		it 'returns the result for nested keys' do
+			result = @nori.find(@hash, 'userResponse', 'accountStatus')
+			expect(result).to eq("active")
+		end
+
+		it 'strips the namespaces from Hash keys' do
+			xml = '<v1:userResponse xmlns:v1="http://example.com"><v1:accountStatus>active</v1:accountStatus></v1:userResponse>'
+			hash = @nori.parse(xml)
+
+			result = @nori.find(hash, 'userResponse', 'accountStatus')
+			expect(result).to eq("active")
+		end
+	end
+
+  context "#parse" do
+    it "defaults to use advanced typecasting" do
+      hash = nori.parse("<value>true</value>")
+      hash["value"].should == true
+    end
+
+    it "defaults to use the Nokogiri parser" do
+      # parsers are loaded lazily by default
+      require "nori/parser/nokogiri"
+
+      Nori::Parser::Nokogiri.should_receive(:parse).and_return({})
+      nori.parse("<any>thing</any>")
+    end
+
+    it "strips the XML" do
+      xml = double("xml")
+      xml.should_receive(:strip).and_return("<any>thing</any>")
+
+      nori.parse(xml).should == { "any" => "thing" }
+    end
+  end
+
+  context "#parse without :advanced_typecasting" do
+    it "can be changed to not typecast too much" do
+      hash = nori(:advanced_typecasting => false).parse("<value>true</value>")
+      hash["value"].should == "true"
+    end
+  end
+
+  context "#parse with :parser" do
+    it "can be configured to use the REXML parser" do
+      # parsers are loaded lazily by default
+      require "nori/parser/rexml"
+
+      Nori::Parser::REXML.should_receive(:parse).and_return({})
+      nori(:parser => :rexml).parse("<any>thing</any>")
+    end
+  end
+
+  context "#parse without :delete_namespace_attributes" do
+    it "can be changed to not delete xmlns attributes" do
+      xml = '<userResponse xmlns="http://schema.company.com/some/path/to/namespace/v1"><accountStatus>active</accountStatus></userResponse>'
+      hash = nori(:delete_namespace_attributes => false).parse(xml)
+      hash.should == {"userResponse" => {"@xmlns" => "http://schema.company.com/some/path/to/namespace/v1", "accountStatus" => "active"}}
+    end
+
+    it "can be changed to not delete xsi attributes" do
+      xml = '<userResponse xsi="abc:myType"><accountStatus>active</accountStatus></userResponse>'
+      hash = nori(:delete_namespace_attributes => false).parse(xml)
+      hash.should == {"userResponse" => {"@xsi" => "abc:myType", "accountStatus" => "active"}}
+    end
+  end
+
+  context "#parse with :delete_namespace_attributes" do
+    it "can be changed to delete xmlns attributes" do
+      xml = '<userResponse xmlns="http://schema.company.com/some/path/to/namespace/v1"><accountStatus>active</accountStatus></userResponse>'
+      hash = nori(:delete_namespace_attributes => true).parse(xml)
+      hash.should == {"userResponse" => {"accountStatus" => "active"}}
+    end
+
+    it "can be changed to delete xsi attributes" do
+      xml = '<userResponse xsi="abc:myType"><accountStatus>active</accountStatus></userResponse>'
+      hash = nori(:delete_namespace_attributes => true).parse(xml)
+      hash.should == {"userResponse" => {"accountStatus" => "active"}}
+    end
+  end
+
+  def nori(options = {})
+    Nori.new(options)
+  end
+
+end

data/spec/nori/core_ext/hash_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe Hash do
+
+  describe "#to_params" do
+
+    {
+      { "foo" => "bar", "baz" => "bat" } => "foo=bar&baz=bat",
+      { "foo" => [ "bar", "baz" ] } => "foo[]=bar&foo[]=baz",
+      { "foo" => [ {"bar" => "1"}, {"bar" => 2} ] } => "foo[][bar]=1&foo[][bar]=2",
+      { "foo" => { "bar" => [ {"baz" => 1}, {"baz" => "2"}  ] } } => "foo[bar][][baz]=1&foo[bar][][baz]=2",
+      { "foo" => {"1" => "bar", "2" => "baz"} } => "foo[1]=bar&foo[2]=baz"
+    }.each do |hash, params|
+      it "should covert hash: #{hash.inspect} to params: #{params.inspect}" do
+        hash.to_params.split('&').sort.should == params.split('&').sort
+      end
+    end
+
+    it "should not leave a trailing &" do
+      {
+        :name => 'Bob',
+        :address => {
+          :street => '111 Ruby Ave.',
+          :city => 'Ruby Central',
+          :phones => ['111-111-1111', '222-222-2222']
+        }
+      }.to_params.should_not =~ /&$/
+    end
+
+    it "should URL encode unsafe characters" do
+      {:q => "?&\" +"}.to_params.should == "q=%3F%26%22%20%2B"
+    end
+  end
+
+  describe "#normalize_param" do
+    it "should have specs"
+  end
+
+  describe "#to_xml_attributes" do
+
+    it "should turn the hash into xml attributes" do
+      attrs = { :one => "ONE", "two" => "TWO" }.to_xml_attributes
+      attrs.should =~ /one="ONE"/m
+      attrs.should =~ /two="TWO"/m
+    end
+
+    it "should preserve _ in hash keys" do
+      attrs = {
+        :some_long_attribute => "with short value",
+        :crash               => :burn,
+        :merb                => "uses extlib"
+      }.to_xml_attributes
+
+      attrs.should =~ /some_long_attribute="with short value"/
+      attrs.should =~ /merb="uses extlib"/
+      attrs.should =~ /crash="burn"/
+    end
+  end
+
+end

data/spec/nori/core_ext/object_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Object do
+
+  describe "#blank?" do
+    [nil, false, [], {}].each do |object|
+      it "should return true for: #{object.inspect}" do
+        object.blank?.should be_true
+      end
+    end
+
+    [true, [nil], 1, "string", { :key => "value" }].each do |object|
+      it "should return false for: #{object.inspect}" do
+        object.blank?.should be_false
+      end
+    end
+  end
+
+end

data/spec/nori/core_ext/string_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe String do
+
+  describe "#snakecase" do
+    it "lowercases one word CamelCase" do
+      "Merb".snakecase.should == "merb"
+    end
+
+    it "makes one underscore snakecase two word CamelCase" do
+      "MerbCore".snakecase.should == "merb_core"
+    end
+
+    it "handles CamelCase with more than 2 words" do
+      "SoYouWantContributeToMerbCore".snakecase.should == "so_you_want_contribute_to_merb_core"
+    end
+
+    it "handles CamelCase with more than 2 capital letter in a row" do
+      "CNN".snakecase.should == "cnn"
+      "CNNNews".snakecase.should == "cnn_news"
+      "HeadlineCNNNews".snakecase.should == "headline_cnn_news"
+    end
+
+    it "does NOT change one word lowercase" do
+      "merb".snakecase.should == "merb"
+    end
+
+    it "leaves snake_case as is" do
+      "merb_core".snakecase.should == "merb_core"
+    end
+  end
+
+end