ruby-oembed 0.14.0 → 0.16.1

data/spec/formatter/json/jsongem_backend_spec.rb

@@ -1,71 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'json'
-
-describe "Setting JSON.backend = 'JSONGem'" do
-  context "without the JSON object defined" do
-    it "should fail" do
-      expect(OEmbed::Formatter::JSON).to receive(:already_loaded?).with('JSONGem').and_return(false)
-      expect(Object).to receive(:const_defined?).with('JSON').and_return(false)
-
-      expect {
-        OEmbed::Formatter::JSON.backend = 'JSONGem'
-      }.to raise_error(LoadError)
-    end
-  end
-
-  context "with the JSON object loaded" do
-    it "should work" do
-      expect(OEmbed::Formatter::JSON).to receive(:already_loaded?).with('JSONGem').and_return(false)
-
-      expect {
-        OEmbed::Formatter::JSON.backend = 'JSONGem'
-      }.to_not raise_error
-    end
-  end
-end
-
-describe "OEmbed::Formatter::JSON::Backends::JSONGem" do
-  include OEmbedSpecHelper
-
-  it "should support JSON" do
-    expect {
-      OEmbed::Formatter.supported?(:json)
-    }.to_not raise_error
-  end
-
-  it "should be using the JSONGem backend" do
-    expect(OEmbed::Formatter::JSON.backend).to eq(OEmbed::Formatter::JSON::Backends::JSONGem)
-  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.
-    expect(decoded.keys).to eq(valid_response(:object).keys)
-    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
-  end
-
-  it "should raise an OEmbed::ParseError when decoding an invalid JSON String" do
-    expect {
-      decode = OEmbed::Formatter.decode(:json, invalid_response('unclosed_container', :json))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:json, invalid_response('unclosed_tag', :json))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:json, invalid_response('invalid_syntax', :json))
-    }.to raise_error(OEmbed::ParseError)
-  end
-
-  it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
-    error_to_raise = ArgumentError
-    expect(OEmbed::Formatter::JSON.backend.parse_error).to_not be_kind_of(error_to_raise)
-
-    expect(::JSON).to receive(:parse).
-      and_throw(error_to_raise.new("unknown error"))
-
-    expect {
-      decode = OEmbed::Formatter.decode(:json, valid_response(:json))
-    }.to raise_error(OEmbed::ParseError)
-  end
-end

data/spec/formatter/json/yaml_backend_spec.rb

@@ -1,55 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "OEmbed::Formatter::JSON::Backends::Yaml" do
-  include OEmbedSpecHelper
-
-  before(:all) do
-    expect {
-      OEmbed::Formatter::JSON.backend = 'Yaml'
-    }.to_not raise_error
-
-    expect(!!defined?(YAML)).to eq(true)
-  end
-
-  it "should support JSON" do
-    expect {
-      OEmbed::Formatter.supported?(:json)
-    }.to_not raise_error
-  end
-
-  it "should be using the Yaml backend" do
-    expect(OEmbed::Formatter::JSON.backend).to eq(OEmbed::Formatter::JSON::Backends::Yaml)
-  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.
-    expect(decoded.keys).to eq(valid_response(:object).keys)
-    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
-  end
-
-  it "should raise an OEmbed::ParseError when decoding an invalid JSON String" do
-    expect {
-      decode = OEmbed::Formatter.decode(:json, invalid_response('unclosed_container', :json))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:json, invalid_response('unclosed_tag', :json))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:json, invalid_response('invalid_syntax', :json))
-    }.to raise_error(OEmbed::ParseError)
-  end
-
-  it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
-    error_to_raise = ArgumentError
-    expect(OEmbed::Formatter::JSON.backend.parse_error).to_not be_kind_of(error_to_raise)
-
-    expect(OEmbed::Formatter::JSON.backend).to receive(:convert_json_to_yaml).
-      and_throw(error_to_raise.new("unknown error"))
-
-    expect {
-      decode = OEmbed::Formatter.decode(:json, valid_response(:json))
-    }.to raise_error(OEmbed::ParseError)
-  end
-end

data/spec/formatter/xml/nokogiri_backend_spec.rb

@@ -1,59 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "OEmbed::Formatter::XML::Backends::Nokogiri" do
-  include OEmbedSpecHelper
-
-  before(:all) do
-    expect {
-      OEmbed::Formatter::XML.backend = 'Nokogiri'
-    }.to raise_error(LoadError)
-
-    require 'nokogiri'
-
-    expect {
-      OEmbed::Formatter::XML.backend = 'Nokogiri'
-    }.to_not raise_error
-  end
-
-  it "should support XML" do
-    expect {
-      OEmbed::Formatter.supported?(:xml)
-    }.to_not raise_error
-  end
-
-  it "should be using the Nokogiri backend" do
-    expect(OEmbed::Formatter::XML.backend).to eq(OEmbed::Formatter::XML::Backends::Nokogiri)
-  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.
-    expect(decoded.keys).to eq(valid_response(:object).keys)
-    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
-  end
-
-  it "should raise an OEmbed::ParseError when decoding an invalid XML String" do
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_container', :xml))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_tag', :xml))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, invalid_response('invalid_syntax', :xml))
-    }.to raise_error(OEmbed::ParseError)
-  end
-
-  it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
-    error_to_raise = ArgumentError
-    expect(OEmbed::Formatter::XML.backend.parse_error).to_not be_kind_of(error_to_raise)
-
-    expect(::Nokogiri::XML::Document).to receive(:parse).
-      and_raise(error_to_raise.new("unknown error"))
-
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, valid_response(:xml))
-    }.to raise_error(OEmbed::ParseError)
-  end
-end

data/spec/formatter/xml/rexml_backend_spec.rb

@@ -1,55 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "OEmbed::Formatter::XML::Backends::REXML" do
-  include OEmbedSpecHelper
-
-  before(:all) do
-    expect {
-      OEmbed::Formatter::XML.backend = 'REXML'
-    }.to_not raise_error
-
-    expect((!!defined?(REXML))).to eq(true)
-  end
-
-  it "should support XML" do
-    expect {
-      OEmbed::Formatter.supported?(:xml)
-    }.to_not raise_error
-  end
-
-  it "should be using the XmlSimple backend" do
-    expect(OEmbed::Formatter::XML.backend).to eq(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.
-    expect(decoded.keys).to eq(valid_response(:object).keys)
-    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
-  end
-
-  it "should raise an OEmbed::ParseError when decoding an invalid XML String" do
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_container', :xml))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_tag', :xml))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, invalid_response('invalid_syntax', :xml))
-    }.to raise_error(OEmbed::ParseError)
-  end
-
-  it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
-    error_to_raise = ArgumentError
-    expect(OEmbed::Formatter::XML.backend.parse_error).to_not be_kind_of(error_to_raise)
-
-    expect(::REXML::Document).to receive(:new).
-      and_raise(error_to_raise.new("unknown error"))
-
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, valid_response(:xml))
-    }.to raise_error(OEmbed::ParseError)
-  end
-end

data/spec/formatter/xml/xmlsimple_backend_spec.rb

@@ -1,59 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "OEmbed::Formatter::XML::Backends::XmlSimple" do
-  include OEmbedSpecHelper
-
-  before(:all) do
-    expect {
-      OEmbed::Formatter::XML.backend = 'XmlSimple'
-    }.to raise_error(LoadError)
-
-    require 'xmlsimple'
-
-    expect {
-      OEmbed::Formatter::XML.backend = 'XmlSimple'
-    }.to_not raise_error
-  end
-
-  it "should support XML" do
-    expect {
-      OEmbed::Formatter.supported?(:xml)
-    }.to_not raise_error
-  end
-
-  it "should be using the XmlSimple backend" do
-    expect(OEmbed::Formatter::XML.backend).to eq(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.
-    expect(decoded.keys).to eq(valid_response(:object).keys)
-    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
-  end
-
-  it "should raise an OEmbed::ParseError when decoding an invalid XML String" do
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_container', :xml))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, invalid_response('unclosed_tag', :xml))
-    }.to raise_error(OEmbed::ParseError)
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, invalid_response('invalid_syntax', :xml))
-    }.to raise_error(OEmbed::ParseError)
-  end
-
-  it "should raise an OEmbed::ParseError when decoding fails with an unexpected error" do
-    error_to_raise = ArgumentError
-    expect(OEmbed::Formatter::XML.backend.parse_error).to_not be_kind_of(error_to_raise)
-
-    expect(::XmlSimple).to receive(:xml_in).
-      and_raise(error_to_raise.new("unknown error"))
-
-    expect {
-      decode = OEmbed::Formatter.decode(:xml, valid_response(:xml))
-    }.to raise_error(OEmbed::ParseError)
-  end
-end

data/spec/formatter_spec.rb

@@ -1,37 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe OEmbed::Formatter do
-  include OEmbedSpecHelper
-
-  it "should support JSON" do
-    expect {
-      OEmbed::Formatter.supported?(:json)
-    }.to_not raise_error
-  end
-
-  it "should default to JSON" do
-    expect(OEmbed::Formatter.default).to eq('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.
-    expect(decoded.keys).to eq(valid_response(:object).keys)
-    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
-  end
-
-  it "should support XML" do
-    expect {
-      OEmbed::Formatter.supported?(:xml)
-    }.to_not raise_error
-  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.
-    expect(decoded.keys).to eq(valid_response(:object).keys)
-    expect(decoded.values.map{|v|v.to_s}).to eq(valid_response(:object).values.map{|v|v.to_s})
-  end
-end

data/spec/provider_discovery_spec.rb

@@ -1,141 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require 'json'
-
-describe OEmbed::ProviderDiscovery do
-  before(:all) do
-    OEmbed::Formatter::JSON.backend = 'JSONGem'
-    VCR.insert_cassette('OEmbed_ProviderDiscovery')
-  end
-  after(:all) do
-    VCR.eject_cassette
-  end
-
-  include OEmbedSpecHelper
-
-  {
-    # 'name' => [
-    #   'given_page_url',
-    #   'expected_endpoint' || {:json=>'expected_json_endpoint', :xml=>'expected_xml_endpoint},
-    #   :expected_format,
-    # ]
-    'youtube' => [
-      'http://www.youtube.com/watch?v=u6XAPnuFjJc',
-      {:json=>'http://www.youtube.com/oembed', :xml=>'http://www.youtube.com/oembed'},
-      :json,
-    ],
-    'vimeo' => [
-      'https://vimeo.com/27953845',
-      {:json=>'https://vimeo.com/api/oembed.json', :xml=>'https://vimeo.com/api/oembed.xml'},
-      :json,
-    ],
-    'facebook-photo' => [
-      'https://www.facebook.com/Federer/photos/pb.64760994940.-2207520000.1456668968./10153235368269941/?type=3&theater',
-      'https://www.facebook.com/plugins/post/oembed.json/',
-      :json,
-    ],
-    'tumblr' => [
-      'http://kittehkats.tumblr.com/post/140525169406/katydid-and-the-egg-happy-forest-family',
-      'https://www.tumblr.com/oembed/1.0',
-      :json
-    ],
-    # TODO: Enhance ProviderDiscovery to support arbitrary query parameters. See https://github.com/ruby-oembed/ruby-oembed/issues/15
-    #'wordpress' => [
-    #  'http://sweetandweak.wordpress.com/2011/09/23/nothing-starts-the-morning-like-a-good-dose-of-panic/',
-    #  {:json=>'https://public-api.wordpress.com/oembed/1.0/', :xml=>'https://public-api.wordpress.com/oembed/1.0/'},
-    #  :json,
-    #],
-  }.each do |context, urls|
-
-    given_url, expected_endpoints, expected_format = urls
-    expected_endpoints = {expected_format=>expected_endpoints} unless expected_endpoints.is_a?(Hash)
-
-    context "given a #{context} url" do
-
-      shared_examples "a discover_provider call" do |endpoint, format|
-        describe ".discover_provider" do
-          it "should return the correct Class" do
-            expect(provider).to be_instance_of(OEmbed::Provider)
-          end
-
-          it "should detect the correct URL" do
-            expect(provider.endpoint).to eq(endpoint)
-          end
-
-          it "should return the correct format" do
-            expect(provider.format).to eq(format)
-          end
-        end
-
-        describe ".get" do
-          it "should return the correct Class" do
-            expect(response).to be_kind_of(OEmbed::Response)
-          end
-
-          it "should return the correct format" do
-            expect(response.format).to eq(format.to_s)
-          end
-
-          it "should return the correct data" do
-            expect(response.type).to_not be_empty
-
-            case response.type
-            when 'video', 'rich'
-              expect(response.html).to_not be_empty
-              expect(response.width).to_not be_nil
-              expect(response.height).to_not be_nil
-            when 'photo'
-              expect(response.url).to_not be_empty
-              expect(response.width).to_not be_nil
-              expect(response.height).to_not be_nil
-            end
-          end
-        end # get
-      end
-
-      context "with no format specified" do
-        let(:provider) { OEmbed::ProviderDiscovery.discover_provider(given_url) }
-        let(:response) { OEmbed::ProviderDiscovery.get(given_url) }
-        include_examples "a discover_provider call", expected_endpoints[expected_format], expected_format
-      end
-
-      if expected_endpoints.include?(:json)
-        context "with json format specified" do
-          let(:provider) { OEmbed::ProviderDiscovery.discover_provider(given_url, :format=>:json) }
-          let(:response) { OEmbed::ProviderDiscovery.get(given_url, :format=>:json) }
-          include_examples "a discover_provider call", expected_endpoints[:json], :json
-        end
-      end
-
-      if expected_endpoints.include?(:xml)
-        context "with json format specified" do
-          let(:provider) { OEmbed::ProviderDiscovery.discover_provider(given_url, :format=>:xml) }
-          let(:response) { OEmbed::ProviderDiscovery.get(given_url, :format=>:xml) }
-          include_examples "a discover_provider call", expected_endpoints[:xml], :xml
-        end
-      end
-    end
-
-  end # each service
-
-  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