ruby-oembed 0.8.14 → 0.9.0

data/spec/provider_discovery_spec.rb

@@ -113,4 +113,25 @@ describe OEmbed::ProviderDiscovery do
 
   end # each service
 
-end
+  context "when returning 404" do
+    let(:url) { 'https://www.youtube.com/watch?v=123123123' }
+
+    it "raises OEmbed::NotFound" do
+      expect{ OEmbed::ProviderDiscovery.discover_provider(url) }.to raise_error(OEmbed::NotFound)
+    end
+  end
+
+  context "when returning 301" do
+    let(:url) { 'http://www.youtube.com/watch?v=dFs9WO2B8uI' }
+
+    it "does redirect http to https" do
+      expect{ OEmbed::ProviderDiscovery.discover_provider(url) }.not_to raise_error
+    end
+  end
+
+  it "does passes the timeout option to Net::Http" do
+    expect_any_instance_of(Net::HTTP).to receive(:open_timeout=).with(5)
+    expect_any_instance_of(Net::HTTP).to receive(:read_timeout=).with(5)
+    OEmbed::ProviderDiscovery.discover_provider('https://www.youtube.com/watch?v=dFs9WO2B8uI', :timeout => 5)
+  end
+end

data/spec/providers_spec.rb

@@ -18,82 +18,82 @@ describe OEmbed::Providers do
 
   describe ".register" do
     it "should register providers" do
-      OEmbed::Providers.urls.should be_empty
-    
+      expect(OEmbed::Providers.urls).to be_empty
+
       OEmbed::Providers.register(@flickr, @qik)
-    
-      OEmbed::Providers.urls.keys.should == @flickr.urls + @qik.urls
+
+      expect(OEmbed::Providers.urls.keys).to eq(@flickr.urls + @qik.urls)
 
       @flickr.urls.each do |regexp|
-        OEmbed::Providers.urls.should have_key(regexp)
-        OEmbed::Providers.urls[regexp].should include(@flickr)
+        expect(OEmbed::Providers.urls).to have_key(regexp)
+        expect(OEmbed::Providers.urls[regexp]).to include(@flickr)
       end
 
       @qik.urls.each do |regexp|
-        OEmbed::Providers.urls.should have_key(regexp)
-        OEmbed::Providers.urls[regexp].should include(@qik)
+        expect(OEmbed::Providers.urls).to have_key(regexp)
+        expect(OEmbed::Providers.urls[regexp]).to include(@qik)
       end
     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
+
+      expect(OEmbed::Providers.find(example_url(:flickr))).to eq(@flickr)
+      expect(OEmbed::Providers.find(example_url(:qik))).to eq(@qik)
     end
   end
 
   describe ".unregister" do
     it "should unregister providers" do
       OEmbed::Providers.register(@flickr, @qik) # tested in "should register providers"
-    
+
       OEmbed::Providers.unregister(@flickr)
-    
+
       @flickr.urls.each do |regexp|
-        OEmbed::Providers.urls.should_not have_key(regexp)
+        expect(OEmbed::Providers.urls).to_not have_key(regexp)
       end
-    
-      OEmbed::Providers.urls.keys.should == @qik.urls
+
+      expect(OEmbed::Providers.urls.keys).to eq(@qik.urls)
 
       @qik.urls.each do |regexp|
-        OEmbed::Providers.urls.should have_key(regexp)
-        OEmbed::Providers.urls[regexp].should include(@qik)
+        expect(OEmbed::Providers.urls).to have_key(regexp)
+        expect(OEmbed::Providers.urls[regexp]).to include(@qik)
       end
     end
 
     it "should not unregister duplicate provider urls at first" do
       @qik_mirror = OEmbed::Provider.new("http://mirror.qik.com/api/oembed.{format}")
       @qik_mirror << "http://qik.com/*"
-    
+
       @qik_mirror.urls.each do |regexp|
-        @qik.urls.should include(regexp)
+        expect(@qik.urls).to include(regexp)
       end
-    
+
       OEmbed::Providers.register(@qik, @qik_mirror)
-    
-      OEmbed::Providers.urls.keys.should == @qik.urls
+
+      expect(OEmbed::Providers.urls.keys).to eq(@qik.urls)
 
       @qik_mirror.urls.each do |regexp|
-        OEmbed::Providers.urls[regexp].should include(@qik_mirror)
-        OEmbed::Providers.urls[regexp].should include(@qik)
+        expect(OEmbed::Providers.urls[regexp]).to include(@qik_mirror)
+        expect(OEmbed::Providers.urls[regexp]).to include(@qik)
       end
-    
-      OEmbed::Providers.find(example_url(:qik)).should == @qik
-    
+
+      expect(OEmbed::Providers.find(example_url(:qik))).to eq(@qik)
+
       OEmbed::Providers.unregister(@qik)
-    
+
       urls = OEmbed::Providers.urls.dup
 
       @qik_mirror.urls.each do |regexp|
-        OEmbed::Providers.urls[regexp].should include(@qik_mirror)
+        expect(OEmbed::Providers.urls[regexp]).to include(@qik_mirror)
       end
-    
-      OEmbed::Providers.find(example_url(:qik)).should == @qik_mirror
-    
+
+      expect(OEmbed::Providers.find(example_url(:qik))).to eq(@qik_mirror)
+
       OEmbed::Providers.unregister(@qik_mirror)
-    
+
       @qik_mirror.urls.each do |regexp|
-        OEmbed::Providers.urls.should_not have_key(regexp)
+        expect(OEmbed::Providers.urls).to_not have_key(regexp)
       end
     end
   end
@@ -114,10 +114,10 @@ describe OEmbed::Providers do
 	#  OEmbed::Providers.register_fallback(OEmbed::ProviderDiscovery)
   #
 	#  provider = OEmbed::ProviderDiscovery
-	#  provider.should_receive(:raw).
+	#  expect(provider).to receive(:raw).
 	#    with(url, {}).
 	#    and_return(valid_response(:raw))
-	#  provider.should_receive(:get).
+	#  expect(provider).to receive(:get).
 	#    with(url, {}).
 	#    and_return(valid_response(:object))
   #end
@@ -127,9 +127,9 @@ describe OEmbed::Providers do
       OEmbed::Providers.register_all
       all_example_urls.each do |url|
         provider = OEmbed::Providers.find(url)
-        expect(provider).should_receive(:raw).
+        expect(provider).to receive(:raw).
           with(url, {})
-        expect(provider).should_receive(:get).
+        expect(provider).to receive(:get).
           with(url, {})
         OEmbed::Providers.raw(url)
         OEmbed::Providers.get(url)
@@ -139,8 +139,8 @@ describe OEmbed::Providers do
     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)
+        expect { OEmbed::Providers.get(url) }.to raise_error(OEmbed::NotFound)
+        expect { OEmbed::Providers.raw(url) }.to raise_error(OEmbed::NotFound)
       end
     end
   end
@@ -150,28 +150,28 @@ describe OEmbed::Providers do
       OEmbed::Providers.register_fallback(OEmbed::Providers::Hulu)
       OEmbed::Providers.register_fallback(OEmbed::Providers::OohEmbed)
 
-      OEmbed::Providers.fallback.should == [ OEmbed::Providers::Hulu, OEmbed::Providers::OohEmbed]
+      expect(OEmbed::Providers.fallback).to eq([ OEmbed::Providers::Hulu, OEmbed::Providers::OohEmbed])
     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
-      provider.should_receive(:raw).
+      expect(provider).to receive(:raw).
         with(url, {}).
         and_return(valid_response(:raw))
-      provider.should_receive(:get).
+      expect(provider).to receive(:get).
         with(url, {}).
         and_return(valid_response(:object))
 
       OEmbed::Providers.fallback.each do |p|
         next if p == provider
-        p.should_receive(:raw).and_raise(OEmbed::NotFound)
-        p.should_receive(:get).and_raise(OEmbed::NotFound)
+        expect(p).to receive(:raw).and_raise(OEmbed::NotFound)
+        expect(p).to receive(:get).and_raise(OEmbed::NotFound)
       end
 
       OEmbed::Providers.raw(url)
@@ -182,10 +182,10 @@ describe OEmbed::Providers do
       OEmbed::Providers.register_all
       OEmbed::Providers.register_fallback(OEmbed::Providers::Hulu)
       OEmbed::Providers.register_fallback(OEmbed::Providers::OohEmbed)
-    
+
       ["http://fa.ke/"].each do |url|
-        proc { OEmbed::Providers.get(url) }.should raise_error(OEmbed::NotFound)
-        proc { OEmbed::Providers.raw(url) }.should raise_error(OEmbed::NotFound)
+        expect { OEmbed::Providers.get(url) }.to raise_error(OEmbed::NotFound)
+        expect { OEmbed::Providers.raw(url) }.to raise_error(OEmbed::NotFound)
       end
     end
   end
@@ -194,26 +194,26 @@ describe OEmbed::Providers do
     after(:each) do
       OEmbed::Providers.send(:remove_const, :Fake) if defined?(OEmbed::Providers::Fake)
     end
-    
+
     it "should not register a provider that is not marked as official" do
-      defined?(OEmbed::Providers::Fake).should_not be
-      
+      expect(defined?(OEmbed::Providers::Fake)).to_not be
+
       class OEmbed::Providers
         Fake = OEmbed::Provider.new("http://new.fa.ke/oembed/")
         Fake << "http://new.fa.ke/*"
       end
-      
+
       OEmbed::Providers.register_all
       ["http://new.fa.ke/20C285E0"].each do |url|
         provider = OEmbed::Providers.find(url)
-        provider.should be_nil
+        expect(provider).to be_nil
       end
     end
-    
+
     describe 'add_official_provider' do
       it "should register a new official provider" do
-        defined?(OEmbed::Providers::Fake).should_not be
-        
+        expect(defined?(OEmbed::Providers::Fake)).to_not be
+
         class OEmbed::Providers
           Fake = OEmbed::Provider.new("http://official.fa.ke/oembed/")
           Fake << "http://official.fa.ke/*"
@@ -222,19 +222,19 @@ describe OEmbed::Providers do
 
         ["http://official.fa.ke/20C285E0"].each do |url|
           provider = OEmbed::Providers.find(url)
-          provider.should_not be_a(OEmbed::Provider)
+          expect(provider).to_not be_a(OEmbed::Provider)
         end
-        
+
         OEmbed::Providers.register_all
         ["http://official.fa.ke/20C285E0"].each do |url|
           provider = OEmbed::Providers.find(url)
-          provider.should be_a(OEmbed::Provider)
+          expect(provider).to be_a(OEmbed::Provider)
         end
       end
 
       it "should register an official sub_type provider separately" do
-        defined?(OEmbed::Providers::Fake).should_not be
-        
+        expect(defined?(OEmbed::Providers::Fake)).to_not be
+
         class OEmbed::Providers
           Fake = OEmbed::Provider.new("http://sub.fa.ke/oembed/")
           Fake << "http://sub.fa.ke/*"
@@ -244,13 +244,13 @@ describe OEmbed::Providers do
         OEmbed::Providers.register_all
         ["http://sub.fa.ke/20C285E0"].each do |url|
           provider = OEmbed::Providers.find(url)
-          provider.should_not be_a(OEmbed::Provider)
+          expect(provider).to_not be_a(OEmbed::Provider)
         end
-        
+
         OEmbed::Providers.register_all(:fakes)
         ["http://sub.fa.ke/20C285E0"].each do |url|
           provider = OEmbed::Providers.find(url)
-          provider.should be_a(OEmbed::Provider)
+          expect(provider).to be_a(OEmbed::Provider)
         end
       end
     end

data/spec/response_spec.rb

@@ -1,5 +1,27 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
+def expected_helpers
+  {
+    "type" => "random",
+    "version" => "1.0",
+    "html" => "<em>Hello world!</em>",
+    "url" => "http://foo.com/bar",
+  }.freeze
+end
+
+def expected_skipped
+  {
+    "fields" => "hello",
+    "__id__" => 1234,
+    "provider" => "oohEmbed",
+    "to_s" => "random string",
+  }.freeze
+end
+
+def all_expected
+  expected_helpers.merge(expected_skipped).freeze
+end
+
 describe OEmbed::Response do
   include OEmbedSpecHelper
 
@@ -42,65 +64,43 @@ describe OEmbed::Response do
     OEmbed::Response.create_for(valid_response(:json), @viddler, example_url(:viddler), :json)
   }
 
-  let(:expected_helpers) {
-    {
-      "type" => "random",
-      "version" => "1.0",
-      "html" => "<em>Hello world!</em>",
-      "url" => "http://foo.com/bar",
-    }
-  }
-
-  let(:expected_skipped) {
-    {
-      "fields" => "hello",
-      "__id__" => 1234,
-      "provider" => "oohEmbed",
-      "to_s" => "random string",
-    }
-  }
-
-  let(:all_expected) {
-    expected_helpers.merge(expected_skipped)
-  }
-
   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}
+      expect(new_res.fields.keys).to eq(valid_response(:object).keys)
+      expect(new_res.fields.values.map{|v|v.to_s}).to eq(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}
+      expect(default_res.fields.keys).to eq(valid_response(:object).keys)
+      expect(default_res.fields.values.map{|v|v.to_s}).to eq(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}
+      expect(xml_res.fields.keys).to eq(valid_response(:object).keys)
+      expect(xml_res.fields.values.map{|v|v.to_s}).to eq(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}
+      expect(json_res.fields.keys).to eq(valid_response(:object).keys)
+      expect(json_res.fields.values.map{|v|v.to_s}).to eq(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
+      expect(new_res.provider).to eq(OEmbed::Providers::OohEmbed)
+      expect(default_res.provider).to eq(@flickr)
+      expect(xml_res.provider).to eq(@qik)
+      expect(json_res.provider).to eq(@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'
+      expect(new_res.format).to be_nil
+      expect(default_res.format.to_s).to eq('json')
+      expect(xml_res.format.to_s).to eq('xml')
+      expect(json_res.format.to_s).to eq('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)
+      expect(new_res.request_url).to be_nil
+      expect(default_res.request_url.to_s).to eq(example_url(:flickr))
+      expect(xml_res.request_url.to_s).to eq(example_url(:qik))
+      expect(json_res.request_url.to_s).to eq(example_url(:viddler))
     end
   end
 
@@ -135,45 +135,55 @@ describe OEmbed::Response do
   end
 
   it "should access the XML data through #field" do
-    xml_res.field(:type).should == "photo"
-    xml_res.field(:version).should == "1.0"
-    xml_res.field(:fields).should == "hello"
-    xml_res.field(:__id__).should == "1234"
+    expect(xml_res.field(:type)).to eq("photo")
+    expect(xml_res.field(:version)).to eq("1.0")
+    expect(xml_res.field(:fields)).to eq("hello")
+    expect(xml_res.field(:__id__)).to eq("1234")
   end
 
   it "should access the JSON data through #field" 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"
+    expect(json_res.field(:type)).to eq("photo")
+    expect(json_res.field(:version)).to eq("1.0")
+    expect(json_res.field(:fields)).to eq("hello")
+    expect(json_res.field(:__id__)).to eq("1234")
   end
 
   describe "#define_methods!" do
-    it "should automagically define helpers" do
-      local_res = OEmbed::Response.new(all_expected, OEmbed::Providers::OohEmbed)
-
+    context "with automagic" do
       all_expected.each do |method, value|
-        local_res.should respond_to(method)
+        before do
+          @local_res = OEmbed::Response.new(all_expected, OEmbed::Providers::OohEmbed)
+        end
+
+        it "should define the #{method} method" do
+          expect(@local_res).to respond_to(method)
+        end
       end
+
       expected_helpers.each do |method, value|
-        local_res.send(method).should == value
+        it "should define #{method} to return #{value.inspect}" do
+          expect(@local_res.send(method)).to eq(value)
+        end
       end
+
       expected_skipped.each do |method, value|
-        local_res.send(method).should_not == value
+        it "should NOT override #{method} to not return #{value.inspect}" do
+          expect(@local_res.send(method)).to_not eq(value)
+        end
       end
     end
 
     it "should protect most already defined methods" do
-      Object.new.should respond_to('__id__')
-      Object.new.should respond_to('to_s')
+      expect(Object.new).to respond_to('__id__')
+      expect(Object.new).to respond_to('to_s')
 
-      all_expected.keys.should include('__id__')
-      all_expected.keys.should include('to_s')
+      expect(all_expected.keys).to include('__id__')
+      expect(all_expected.keys).to 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')
+      expect(local_res.__id__).to_not eq(local_res.field('__id__'))
+      expect(local_res.to_s).to_not eq(local_res.field('to_s'))
     end
 
     it "should not protect already defined methods that are specifically overridable" do
@@ -183,16 +193,16 @@ describe OEmbed::Response do
         end
       end
 
-      Object.new.should respond_to('version')
-      String.new.should respond_to('version')
+      expect(Object.new).to respond_to('version')
+      expect(String.new).to respond_to('version')
 
-      all_expected.keys.should include('version')
-      all_expected['version'].should_not == String.new.version
+      expect(all_expected.keys).to include('version')
+      expect(all_expected['version']).to_not eq(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
+      expect(local_res.version).to eq(local_res.field('version'))
+      expect(local_res.version).to_not eq(String.new.version)
     end
   end
 
@@ -200,19 +210,19 @@ describe OEmbed::Response do
     describe "#html" do
       it "should include the title, if given" do
         response = OEmbed::Response.create_for(example_body(:flickr), example_url(:flickr), flickr, :json)
-        response.should respond_to(:title)
-        response.title.should_not be_empty
+        expect(response).to respond_to(:title)
+        expect(response.title).to_not be_empty
 
-        response.html.should_not be_nil
-        response.html.should match(/alt='#{response.title}'/)
+        expect(response.html).to_not be_nil
+        expect(response.html).to match(/alt='#{response.title}'/)
       end
 
       it "should work just fine, without a title" do
         response = OEmbed::Response.create_for(example_body(:skitch), example_url(:skitch), skitch, :json)
-        response.should_not respond_to(:title)
+        expect(response).to_not respond_to(:title)
 
-        response.html.should_not be_nil
-        response.html.should match(/alt=''/)
+        expect(response.html).to_not be_nil
+        expect(response.html).to match(/alt=''/)
       end
     end
   end