ruby-oembed 0.7.6 → 0.8.1

data/spec/formatter/xml/rexml_backend_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "OEmbed::Formatter::XML::Backends::REXML" do
+  include OEmbedSpecHelper
+
+  before(:all) do
+    lambda {
+      OEmbed::Formatter::XML.backend = 'REXML'
+    }.should_not raise_error
+    
+    (!!defined?(REXML)).should == true
+  end
+
+  it "should support XML" do
+    proc { OEmbed::Formatter.supported?(:xml) }.
+    should_not raise_error(OEmbed::FormatNotSupported)
+  end
+  
+  it "should be using the XmlSimple backend" do
+    OEmbed::Formatter::XML.backend.should == OEmbed::Formatter::XML::Backends::REXML
+  end
+  
+  it "should decode an XML String" do
+    decoded = OEmbed::Formatter.decode(:xml, valid_response(:xml))
+    # We need to compare keys & values separately because we don't expect all
+    # non-string values to be recognized correctly.
+    decoded.keys.should == valid_response(:object).keys
+    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+  end
+end

data/spec/formatter/xml/xmlsimple_backend_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "OEmbed::Formatter::XML::Backends::XmlSimple" do
+  include OEmbedSpecHelper
+
+  before(:all) do
+    lambda {
+      OEmbed::Formatter::XML.backend = 'XmlSimple'
+    }.should raise_error(LoadError)
+    
+    require 'xmlsimple'
+    
+    lambda {
+      OEmbed::Formatter::XML.backend = 'XmlSimple'
+    }.should_not raise_error
+  end
+
+  it "should support XML" do
+    proc { OEmbed::Formatter.supported?(:xml) }.
+    should_not raise_error(OEmbed::FormatNotSupported)
+  end
+  
+  it "should be using the XmlSimple backend" do
+    OEmbed::Formatter::XML.backend.should == OEmbed::Formatter::XML::Backends::XmlSimple
+  end
+  
+  it "should decode an XML String" do
+    decoded = OEmbed::Formatter.decode(:xml, valid_response(:xml))
+    # We need to compare keys & values separately because we don't expect all
+    # non-string values to be recognized correctly.
+    decoded.keys.should == valid_response(:object).keys
+    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+  end
+end

data/spec/formatter_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe OEmbed::Formatter do
+  include OEmbedSpecHelper
+
+  it "should support JSON" do
+    proc { OEmbed::Formatter.support?(:json) }.
+    should_not raise_error(OEmbed::FormatNotSupported)
+  end
+  
+  it "should default to JSON" do
+    OEmbed::Formatter.default.should == 'json'
+  end
+  
+  it "should decode a JSON String" do
+    decoded = OEmbed::Formatter.decode(:json, valid_response(:json))
+    # We need to compare keys & values separately because we don't expect all
+    # non-string values to be recognized correctly.
+    decoded.keys.should == valid_response(:object).keys
+    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+  end
+  
+  it "should support XML" do
+    proc { OEmbed::Formatter.support?(:xml) }.
+    should_not raise_error(OEmbed::FormatNotSupported)
+  end
+  
+  it "should decode an XML String" do
+    decoded = OEmbed::Formatter.decode(:xml, valid_response(:xml))
+    # We need to compare keys & values separately because we don't expect all
+    # non-string values to be recognized correctly.
+    decoded.keys.should == valid_response(:object).keys
+    decoded.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+  end
+end

data/spec/provider_spec.rb

@@ -4,7 +4,7 @@ describe OEmbed::Provider do
   include OEmbedSpecHelper
 
   before(:all) do
-    @default = OEmbed::Formatters::DEFAULT
+    @default = OEmbed::Formatter.default
     @flickr = OEmbed::Provider.new("http://www.flickr.com/services/oembed/")
     @qik = OEmbed::Provider.new("http://qik.com/api/oembed.{format}", :xml)
     @viddler = OEmbed::Provider.new("http://lab.viddler.com/services/oembed/", :json)
@@ -15,7 +15,143 @@ describe OEmbed::Provider do
     @viddler << "http://*.viddler.com/*"
   end
 
-  it "should by default use OEmbed::Formatters::DEFAULT" do
+  it "should require a valid endpoint for a new instance" do
+    proc { OEmbed::Provider.new("http://foo.com/oembed/") }.
+    should_not raise_error(ArgumentError)
+    
+    proc { OEmbed::Provider.new("https://foo.com/oembed/") }.
+    should_not raise_error(ArgumentError)
+  end
+  
+  it "should allow a {format} string in the endpoint for a new instance" do
+    proc { OEmbed::Provider.new("http://foo.com/oembed.{format}/get") }.
+    should_not raise_error(ArgumentError)
+  end
+  
+  it "should raise an ArgumentError given an invalid endpoint for a new instance" do
+    [
+      "httpx://foo.com/oembed/",
+      "ftp://foo.com/oembed/",
+      "foo.com/oembed/",
+      "http://not a uri",
+      nil, 1,
+    ].each do |endpoint|
+      #puts "given a endpoint of #{endpoint.inspect}"
+      proc { OEmbed::Provider.new(endpoint) }.
+      should raise_error(ArgumentError)
+    end
+  end
+
+  it "should allow no URI schema to be given" do
+    provier = OEmbed::Provider.new("http://foo.com/oembed")
+    
+    provier.include?("http://foo.com/1").should be_true
+    provier.include?("http://bar.foo.com/1").should be_true
+    provier.include?("http://bar.foo.com/show/1").should be_true
+    provier.include?("https://bar.foo.com/1").should be_true
+    provier.include?("http://asdf.com/1").should be_true
+    provier.include?("asdf").should be_true
+  end
+
+  it "should allow a String as a URI schema" do
+    provier = OEmbed::Provider.new("http://foo.com/oembed")
+    provier << "http://bar.foo.com/*"
+    
+    provier.include?("http://bar.foo.com/1").should be_true
+    provier.include?("http://bar.foo.com/show/1").should be_true
+    
+    provier.include?("https://bar.foo.com/1").should be_false
+    provier.include?("http://foo.com/1").should be_false
+  end
+  
+  it "should allow multiple path wildcards in a String URI schema" do
+    provier = OEmbed::Provider.new("http://foo.com/oembed")
+    provier << "http://bar.foo.com/*/show/*"
+    
+    provier.include?("http://bar.foo.com/photo/show/1").should be_true
+    provier.include?("http://bar.foo.com/video/show/2").should be_true
+    provier.include?("http://bar.foo.com/help/video/show/2").should be_true
+    
+    provier.include?("https://bar.foo.com/photo/show/1").should be_false
+    provier.include?("http://foo.com/video/show/2").should be_false
+    provier.include?("http://bar.foo.com/show/1").should be_false
+    provier.include?("http://bar.foo.com/1").should be_false
+  end
+  
+  it "should NOT allow multiple domain wildcards in a String URI schema" do
+    provier = OEmbed::Provider.new("http://foo.com/oembed")
+    
+    pending("We don't yet validate URL schema strings") do
+      proc { provier << "http://*.com/*" }.
+      should raise_error(ArgumentError)
+    end
+    
+    provier.include?("http://foo.com/1").should be_false
+  end
+  
+  it "should allow a sub-domain wildcard in String URI schema" do
+    provier = OEmbed::Provider.new("http://foo.com/oembed")
+    provier << "http://*.foo.com/*"
+    
+    provier.include?("http://bar.foo.com/1").should be_true
+    provier.include?("http://foo.foo.com/2").should be_true
+    provier.include?("http://foo.com/3").should be_true
+    
+    provier.include?("https://bar.foo.com/1").should be_false
+    provier.include?("http://my.bar.foo.com/1").should be_false
+    
+    provier << "http://my.*.foo.com/*"
+  end
+  
+  it "should allow multiple sub-domain wildcards in a String URI schema" do
+    provier = OEmbed::Provider.new("http://foo.com/oembed")
+    provier << "http://*.my.*.foo.com/*"
+    
+    provier.include?("http://my.bar.foo.com/1").should be_true
+    provier.include?("http://my.foo.com/2").should be_true
+    provier.include?("http://bar.my.bar.foo.com/3").should be_true
+    
+    provier.include?("http://bar.foo.com/1").should be_false
+    provier.include?("http://foo.bar.foo.com/1").should be_false
+  end
+  
+  it "should NOT allow a scheme wildcard in a String URI schema" do
+    provier = OEmbed::Provider.new("http://foo.com/oembed")
+    
+    pending("We don't yet validate URL schema strings") do
+      proc { provier << "*://foo.com/*" }.
+      should raise_error(ArgumentError)
+    end
+    
+    provier.include?("http://foo.com/1").should be_false
+  end
+
+  it "should allow a scheme other than http in a String URI schema" do
+    provier = OEmbed::Provider.new("http://foo.com/oembed")
+    provier << "https://foo.com/*"
+    
+    provier.include?("https://foo.com/1").should be_true
+    
+    gopher_url = "gopher://foo.com/1"
+    provier.include?(gopher_url).should be_false
+    provier << "gopher://foo.com/*"
+    provier.include?(gopher_url).should be_true
+  end
+
+  it "should allow a Regexp as a URI schema" do
+    provier = OEmbed::Provider.new("http://foo.com/oembed")
+    provier << %r{^https?://([^\.]*\.)?foo.com/(show/)?\d+}
+    
+    provier.include?("http://bar.foo.com/1").should be_true
+    provier.include?("http://bar.foo.com/show/1").should be_true
+    provier.include?("http://foo.com/1").should be_true
+    provier.include?("https://bar.foo.com/1").should be_true
+    
+    provier.include?("http://bar.foo.com/video/1").should be_false
+    provier.include?("gopher://foo.com/1").should be_false
+  end
+
+  it "should by default use OEmbed::Formatter.default" do
     @flickr.format.should == @default
   end
 
@@ -27,8 +163,24 @@ describe OEmbed::Provider do
     @viddler.format.should == :json
   end
 
-  it "should not allow random formats" do
-    proc { OEmbed::Provider.new("http://www.hulu.com/api/oembed.{format}", :yml) }.
+  it "should allow random formats on initialization" do
+    proc {
+      yaml_provider = OEmbed::Provider.new("http://foo.com/api/oembed.{format}", :yml)
+      yaml_provider << "http://foo.com/*"
+    }.
+    should_not raise_error
+  end
+  
+  it "should not allow random formats to be parsed" do
+    yaml_provider = OEmbed::Provider.new("http://foo.com/api/oembed.{format}", :yml)
+    yaml_provider << "http://foo.com/*"
+    yaml_url = "http://foo.com/video/1"
+    
+    yaml_provider.should_receive(:raw).
+      with(yaml_url, {:format=>:yml}).
+      and_return(valid_response(:json))
+    
+    proc { yaml_provider.get(yaml_url) }.
     should raise_error(OEmbed::FormatNotSupported)
   end
 
@@ -43,32 +195,28 @@ describe OEmbed::Provider do
     @qik.include?(example_url(:qik)).should be_true
   end
 
-  it "should detect if the format is in the URL" do
-    @flickr.format_in_url?.should be_false
-    @qik.format_in_url?.should be_true
-  end
-
   it "should raise error if the URL is invalid" do
-    proc{ @flickr.build(example_url(:fake)) }.should raise_error(OEmbed::NotFound)
-    proc{ @qik.build(example_url(:fake)) }.should raise_error(OEmbed::NotFound)
+    proc{ @flickr.send(:build, example_url(:fake)) }.should raise_error(OEmbed::NotFound)
+    proc{ @qik.send(:build, example_url(:fake)) }.should raise_error(OEmbed::NotFound)
   end
 
   describe "#build" do
     it "should return a proper URL" do
-      uri = @flickr.build(example_url(:flickr))
+      uri = @flickr.send(:build, example_url(:flickr))
       uri.host.should == "www.flickr.com"
       uri.path.should == "/services/oembed/"
       uri.query.include?("format=#{@flickr.format}").should be_true
       uri.query.include?("url=http://flickr.com/photos/bees/2362225867/").should be_true
 
-      uri = @qik.build(example_url(:qik))
+      uri = @qik.send(:build, example_url(:qik))
       uri.host.should == "qik.com"
       uri.path.should == "/api/oembed.xml"
+      uri.query.include?("format=#{@qik.format}").should be_false
       uri.query.should == "url=http://qik.com/video/49565"
     end
 
     it "should accept parameters" do
-      uri = @flickr.build(example_url(:flickr),
+      uri = @flickr.send(:build, example_url(:flickr),
         :maxwidth => 600,
         :maxheight => 200,
         :format => :xml,
@@ -81,7 +229,7 @@ describe OEmbed::Provider do
     end
 
     it "should build correctly when format is in the endpoint URL" do
-      uri = @qik.build(example_url(:qik), :format => :json)
+      uri = @qik.send(:build, example_url(:qik), :format => :json)
       uri.path.should == "/api/oembed.json"
     end
   end
@@ -95,7 +243,7 @@ describe OEmbed::Provider do
       end
       Net::HTTP.stub!(:start).and_return(res)
 
-      @flickr.raw(example_url(:flickr)).should == "raw content"
+      @flickr.send(:raw, example_url(:flickr)).should == "raw content"
     end
 
     it "should raise error on 501" do
@@ -103,7 +251,7 @@ describe OEmbed::Provider do
       Net::HTTP.stub!(:start).and_return(res)
 
       proc do
-        @flickr.raw(example_url(:flickr))
+        @flickr.send(:raw, example_url(:flickr))
       end.should raise_error(OEmbed::UnknownFormat)
     end
 
@@ -112,7 +260,7 @@ describe OEmbed::Provider do
       Net::HTTP.stub!(:start).and_return(res)
 
       proc do
-        @flickr.raw(example_url(:flickr))
+        @flickr.send(:raw, example_url(:flickr))
       end.should raise_error(OEmbed::NotFound)
     end
 
@@ -124,7 +272,7 @@ describe OEmbed::Provider do
         Net::HTTP.stub!(:start).and_return(r)
 
         proc do
-          @flickr.raw(example_url(:flickr))
+          @flickr.send(:raw, example_url(:flickr))
         end.should raise_error(OEmbed::UnknownResponse)
       end
     end
@@ -149,6 +297,28 @@ describe OEmbed::Provider do
         @flickr.get(example_url(:flickr), :format=>:yml)
       end.should raise_error(OEmbed::FormatNotSupported)
     end
+    
+    it "should return OEmbed::Response" do
+      @flickr.stub!(:raw).and_return(valid_response(@default))
+      @flickr.get(example_url(:flickr)).should be_a(OEmbed::Response)
+    end
+
+    it "should be calling OEmbed::Response#create_for internally" do
+      @flickr.stub!(:raw).and_return(valid_response(@default))
+      OEmbed::Response.should_receive(:create_for).
+        with(valid_response(@default), @flickr, example_url(:flickr), @default.to_s)
+      @flickr.get(example_url(:flickr))
+
+      @qik.stub!(:raw).and_return(valid_response(:xml))
+      OEmbed::Response.should_receive(:create_for).
+        with(valid_response(:xml), @qik, example_url(:qik), 'xml')
+      @qik.get(example_url(:qik))
+
+      @viddler.stub!(:raw).and_return(valid_response(:json))
+      OEmbed::Response.should_receive(:create_for).
+        with(valid_response(:json), @viddler, example_url(:viddler), 'json')
+      @viddler.get(example_url(:viddler))
+    end
 
     it "should send the provider's format if none is specified" do
       @flickr.should_receive(:raw).
@@ -166,10 +336,5 @@ describe OEmbed::Provider do
         and_return(valid_response(:json))
       @viddler.get(example_url(:viddler))
     end
-
-    it "should return OEmbed::Response" do
-      @flickr.stub!(:raw).and_return(valid_response(@default))
-      @flickr.get(example_url(:flickr)).is_a?(OEmbed::Response).should be_true
-    end
   end
 end

data/spec/providers_spec.rb

@@ -12,7 +12,13 @@ describe OEmbed::Providers do
     @qik << "http://qik.com/*"
   end
 
+  after(:each) do
+    OEmbed::Providers.unregister_all
+  end
+
   it "should register providers" do
+    OEmbed::Providers.urls.should be_empty
+    
     OEmbed::Providers.register(@flickr, @qik)
     
     OEmbed::Providers.urls.keys.should == @flickr.urls + @qik.urls
@@ -29,11 +35,15 @@ describe OEmbed::Providers do
   end
 
   it "should find by URLs" do
+    OEmbed::Providers.register(@flickr, @qik) # tested in "should register providers"
+    
     OEmbed::Providers.find(example_url(:flickr)).should == @flickr
     OEmbed::Providers.find(example_url(:qik)).should == @qik
   end
 
   it "should unregister providers" do
+    OEmbed::Providers.register(@flickr, @qik) # tested in "should register providers"
+    
     OEmbed::Providers.unregister(@flickr)
     
     @flickr.urls.each do |regexp|
@@ -56,7 +66,7 @@ describe OEmbed::Providers do
       @qik.urls.should include(regexp)
     end
     
-    OEmbed::Providers.register(@qik_mirror)
+    OEmbed::Providers.register(@qik, @qik_mirror)
     
     OEmbed::Providers.urls.keys.should == @qik.urls
 
@@ -122,6 +132,7 @@ describe OEmbed::Providers do
   end
 
   it "should raise an error if no embeddable content is found" do
+    OEmbed::Providers.register_all
     ["http://fake.com/", example_url(:google_video)].each do |url|
       proc { OEmbed::Providers.get(url) }.should raise_error(OEmbed::NotFound)
       proc { OEmbed::Providers.raw(url) }.should raise_error(OEmbed::NotFound)
@@ -136,6 +147,10 @@ describe OEmbed::Providers do
   end
 
   it "should fallback to the appropriate provider when URL isn't found" do
+    OEmbed::Providers.register_all
+    OEmbed::Providers.register_fallback(OEmbed::Providers::Hulu)
+    OEmbed::Providers.register_fallback(OEmbed::Providers::OohEmbed)
+    
     url = example_url(:google_video)
 
     provider = OEmbed::Providers.fallback.last
@@ -157,6 +172,10 @@ describe OEmbed::Providers do
   end
 
   it "should still raise an error if no embeddable content is found" do
+    OEmbed::Providers.register_all
+    OEmbed::Providers.register_fallback(OEmbed::Providers::Hulu)
+    OEmbed::Providers.register_fallback(OEmbed::Providers::OohEmbed)
+    
     ["http://fake.com/"].each do |url|
       proc { OEmbed::Providers.get(url) }.should raise_error(OEmbed::NotFound)
       proc { OEmbed::Providers.raw(url) }.should raise_error(OEmbed::NotFound)

data/spec/response_spec.rb

@@ -15,53 +15,95 @@ describe OEmbed::Response do
 
     @new_res = OEmbed::Response.new(valid_response(:object), OEmbed::Providers::OohEmbed)
 
-    @default_res = OEmbed::Response.create_for(valid_response(:json), @flickr, example_url(:flickr))
+    @default_res = OEmbed::Response.create_for(valid_response(:json), @flickr, example_url(:flickr), :json)
     @xml_res = OEmbed::Response.create_for(valid_response(:xml), @qik, example_url(:qik), :xml)
     @json_res = OEmbed::Response.create_for(valid_response(:json), @viddler, example_url(:viddler), :json)
-  end
-
-  it "should set the provider" do
-    @new_res.provider.should == OEmbed::Providers::OohEmbed
-
-    @default_res.provider.should == @flickr
-    @xml_res.provider.should == @qik
-    @json_res.provider.should == @viddler
-  end
-
-  it "should parse the data into #fields" do
-    @new_res.fields.keys.should == valid_response(:object).keys
 
-    @default_res.fields.keys.should == valid_response(:object).keys
-    @xml_res.fields.keys.should == valid_response(:object).keys
-    @json_res.fields.keys.should == valid_response(:object).keys
+    # These keys should be turned into helper methods
+    @expected_helpers = {
+      "type" => "random",
+      "version" => "1.0",
+      "html" => "<em>Hello world!</em>",
+      "url" => "http://foo.com/bar",
+    }
+    # These keys should already be defined 
+    @expected_skipped = {
+      "fields" => "hello",
+      "__id__" => 1234,
+      "provider" => "oohEmbed",
+      "to_s" => "random string",
+    }
+    @all_expected = @expected_helpers.merge(@expected_skipped)
   end
 
-  it "should only allow JSON or XML" do
-    lambda do
-      OEmbed::Response.create_for(valid_response(:json), @flickr, example_url(:flickr), :json)
-    end.should_not raise_error(OEmbed::FormatNotSupported)
-
-    lambda do
-      OEmbed::Response.create_for(valid_response(:xml), @flickr, example_url(:flickr), :xml)
-    end.should_not raise_error(OEmbed::FormatNotSupported)
-
-    lambda do
-      OEmbed::Response.create_for(valid_response(:yml), @flickr, example_url(:flickr), :yml)
-    end.should raise_error(OEmbed::FormatNotSupported)
+  describe "#initialize" do
+    it "should parse the data into fields" do
+      # We need to compare keys & values separately because we don't expect all
+      # non-string values to be recognized correctly.
+
+      @new_res.fields.keys.should == valid_response(:object).keys
+      @new_res.fields.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+
+      @default_res.fields.keys.should == valid_response(:object).keys
+      @default_res.fields.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+
+      @xml_res.fields.keys.should == valid_response(:object).keys
+      @xml_res.fields.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+
+      @json_res.fields.keys.should == valid_response(:object).keys
+      @json_res.fields.values.map{|v|v.to_s}.should == valid_response(:object).values.map{|v|v.to_s}
+    end
+
+    it "should set the provider" do
+      @new_res.provider.should == OEmbed::Providers::OohEmbed
+      @default_res.provider.should == @flickr
+      @xml_res.provider.should == @qik
+      @json_res.provider.should == @viddler
+    end
+
+    it "should set the format" do
+      @new_res.format.should be_nil
+      @default_res.format.to_s.should == 'json'
+      @xml_res.format.to_s.should == 'xml'
+      @json_res.format.to_s.should == 'json'
+    end
+
+    it "should set the request_url" do
+      @new_res.request_url.should be_nil
+      @default_res.request_url.to_s.should == example_url(:flickr)
+      @xml_res.request_url.to_s.should == example_url(:qik)
+      @json_res.request_url.to_s.should == example_url(:viddler)
+    end
   end
 
-  it "should not parse the incorrect format" do
-    lambda do
-      OEmbed::Response.create_for(valid_response(:xml), example_url(:flickr), @flickr)
-    end.should raise_error(JSON::ParserError)
-
-    lambda do
-      OEmbed::Response.create_for(valid_response(:xml), example_url(:flickr), @viddler, :json)
-    end.should raise_error(JSON::ParserError)
-
-    lambda do
-      OEmbed::Response.create_for(valid_response(:json), example_url(:flickr), @viddler, :xml)
-    end.should raise_error(ArgumentError)
+  describe "create_for" do
+    it "should only allow JSON or XML" do
+      lambda do
+        OEmbed::Response.create_for(valid_response(:json), @flickr, example_url(:flickr), :json)
+      end.should_not raise_error(OEmbed::FormatNotSupported)
+
+      lambda do
+        OEmbed::Response.create_for(valid_response(:xml), @flickr, example_url(:flickr), :xml)
+      end.should_not raise_error(OEmbed::FormatNotSupported)
+
+      lambda do
+        OEmbed::Response.create_for(valid_response(:yml), @flickr, example_url(:flickr), :yml)
+      end.should raise_error(OEmbed::FormatNotSupported)
+    end
+
+    it "should not parse the incorrect format" do
+      lambda do
+        OEmbed::Response.create_for(valid_response(:object), example_url(:flickr), @flickr, :json)
+      end.should raise_error(OEmbed::ParseError)
+
+      lambda do
+        OEmbed::Response.create_for(valid_response(:xml), example_url(:flickr), @viddler, :json)
+      end.should raise_error(OEmbed::ParseError)
+
+      lambda do
+        OEmbed::Response.create_for(valid_response(:json), example_url(:flickr), @viddler, :xml)
+      end.should raise_error(OEmbed::ParseError)
+    end
   end
 
   it "should access the XML data through #field" do
@@ -75,16 +117,55 @@ describe OEmbed::Response do
     @json_res.field(:type).should == "photo"
     @json_res.field(:version).should == "1.0"
     @json_res.field(:fields).should == "hello"
-    @json_res.field(:__id__).should == 1234
+    @json_res.field(:__id__).should == "1234"
   end
 
-  it "should automagically define helpers" do
-    @default_res.type.should == "photo"
-    @default_res.version.should == "1.0"
-  end
+  describe "#define_methods!" do
+    it "should automagically define helpers" do
+      local_res = OEmbed::Response.new(@all_expected, OEmbed::Providers::OohEmbed)
 
-  it "should protect important methods" do
-    @default_res.fields.should_not == @default_res.field(:fields)
-    @default_res.__id__.should_not == @default_res.field(:__id__)
+      @all_expected.each do |method, value|
+        local_res.should respond_to(method)
+      end
+      @expected_helpers.each do |method, value|
+        local_res.send(method).should == value
+      end
+      @expected_skipped.each do |method, value|
+        local_res.send(method).should_not == value
+      end
+    end
+
+    it "should protect most already defined methods" do
+      Object.new.should respond_to('__id__')
+      Object.new.should respond_to('to_s')
+
+      @all_expected.keys.should include('__id__')
+      @all_expected.keys.should include('to_s')
+
+      local_res = OEmbed::Response.new(@all_expected, OEmbed::Providers::OohEmbed)
+
+      local_res.__id__.should_not == local_res.field('__id__')
+      local_res.to_s.should_not == local_res.field('to_s')
+    end
+
+    it "should not protect already defined methods that are specifically overridable" do
+      class Object
+        def version
+          "two point oh"
+        end
+      end
+
+      Object.new.should respond_to('version')
+      String.new.should respond_to('version')
+
+      @all_expected.keys.should include('version')
+      @all_expected['version'].should_not == String.new.version
+
+      local_res = OEmbed::Response.new(@all_expected, OEmbed::Providers::OohEmbed)
+
+      local_res.version.should == local_res.field('version')
+      local_res.version.should_not == String.new.version
+    end
   end
+
 end