onebox 1.1.0 → 1.2.0

data/spec/lib/onebox/engine/whitelisted_generic_onebox_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Onebox::Engine::WhitelistedGenericOnebox do
+
+  describe ".===" do
+    before do
+      described_class.whitelist = %w(eviltrout.com discourse.org)
+    end
+
+    it "matches an entire domain" do
+      expect(described_class === URI('http://eviltrout.com/resource')).to eq(true)
+    end
+
+    it "matches a subdomain" do
+      expect(described_class === URI('http://www.eviltrout.com/resource')).to eq(true)
+    end
+
+    it "doesn't match a different domain" do
+      expect(described_class === URI('http://goodtuna.com/resource')).to eq(false)
+    end
+
+    it "doesn't match the period as any character" do
+      expect(described_class === URI('http://eviltrouticom/resource')).to eq(false)
+    end
+
+    it "doesn't match a prefixed domain" do
+      expect(described_class === URI('http://aneviltrout.com/resource')).to eq(false)
+    end
+  end
+
+
+  describe 'rewrites' do
+    class DummyOnebox < Onebox::Engine::WhitelistedGenericOnebox
+      def generic_html
+        "<iframe src='https://youtube.com/asdf'></iframe>"
+      end
+    end
+
+    it "doesn't rewrite URLs that arent in the list" do
+      Onebox::Engine::WhitelistedGenericOnebox.rewrites = []
+      DummyOnebox.new("http://youtube.com").to_html.should == "<iframe src='https://youtube.com/asdf'></iframe>"
+    end
+
+    it "rewrites URLs when whitelisted" do
+      Onebox::Engine::WhitelistedGenericOnebox.rewrites = %w(youtube.com)
+      DummyOnebox.new("http://youtube.com").to_html.should == "<iframe src='//youtube.com/asdf'></iframe>"
+    end
+  end
+
+
+end

data/spec/lib/onebox/engine/wikipedia_onebox_spec.rb

@@ -3,31 +3,18 @@ require "spec_helper"
 describe Onebox::Engine::WikipediaOnebox do
   before(:all) do
     @link = "http://en.wikipedia.org/wiki/Kevin_Bacon"
-    fake(@link, response(described_class.template_name))
   end
-  before(:each) { Onebox.defaults.cache.clear }
-
-  let(:link) { @link }
 
+  include_context "engines"
   it_behaves_like "an engine"
 
   describe "#to_html" do
-    let(:html) { described_class.new(link).to_html }
-
-    it "returns the product URL" do
-      expect(html).to include(link)
-    end
-
-    it "returns the article title" do
-      expect(html).to include("Kevin Bacon")
-    end
-
-    it "returns the article img src" do
+    it "includes article image" do
       expect(html).to include("225px-Kevin_Bacon_Comic-Con_2012.jpg")
     end
 
-    it "returns the article summary" do
-      expect(html).to include("Kevin Norwood Bacon[1] (born July 8, 1958)")
+    it "includes summary" do
+      expect(html).to include("Kevin Norwood Bacon (born July 8, 1958)")
     end
   end
 end

data/spec/lib/onebox/engine/youtube_onebox_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Onebox::Engine::YoutubeOnebox do
+  before do
+    fake("https://www.youtube.com/watch?v=21Lk4YiASMo", response("youtube"))
+    fake("http://www.youtube.com/oembed?format=json&url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D21Lk4YiASMo", response("youtube-json"))
+  end
+
+  it "should add wmode=opaque" do
+    Onebox.preview('https://www.youtube.com/watch?v=21Lk4YiASMo').to_s.should match(/wmode=opaque/)
+  end
+
+  it "should rewrite URLs to be agnostic" do
+    Onebox.preview('https://www.youtube.com/watch?v=21Lk4YiASMo').to_s.should match(/"\/\//)
+  end
+end
+

data/spec/lib/onebox/engine_spec.rb

@@ -1,31 +1,26 @@
 require "spec_helper"
 
-class OneboxEngineExample
-  include Onebox::Engine
+describe Onebox::Engine do
+  class OneboxEngineExample
+    include Onebox::Engine
 
-  def data
-    { foo: raw[:key], url: @url }
-  end
+    def to_html
+      "Hello #{link}"
+    end
 
-  def raw
-    { key: "value" }
-  end
+    def data
+      { foo: raw[:key], url: @url }
+    end
 
-  def view
-    @view.tap do |layout|
-      layout.view.template = %|<div class="onebox"><a href="{{url}}"></a></div>|
+    def raw
+      { key: "value" }
     end
   end
-end
 
-describe Onebox::Engine do
-  describe "#to_html" do
-    it "returns the onebox wrapper" do
-      html = OneboxEngineExample.new("foo").to_html
-      expect(html).to include(%|class="onebox"|)
-    end
+  describe "#link" do
+    before { Onebox::View.any_instance.stub(:template) { %|this shold be a template| } }
 
-    it "doesn't allow XSS injection" do
+    it "escapes `link`" do
       html = OneboxEngineExample.new(%|http://foo.com" onscript="alert('foo')|).to_html
       expect(html).not_to include(%|onscript="alert('foo')|)
     end
@@ -53,13 +48,20 @@ describe Onebox::Engine do
     end
   end
 
+  describe '.placeholder_html' do
+    let(:onebox) { OneboxEngineExample.new('http://eviltrout.com') }
+    it "returns `to_html` by default" do
+      expect(onebox.to_html).to eq(onebox.placeholder_html)
+    end
+  end
+
   describe ".===" do
     class OneboxEngineTripleEqual
       include Onebox::Engine
       @@matcher = /example/
     end
     it "returns true if argument matches the matcher" do
-      result = OneboxEngineTripleEqual === "http://www.example.com/product/5?var=foo&bar=5"
+      result = OneboxEngineTripleEqual === URI("http://www.example.com/product/5?var=foo&bar=5")
       expect(result).to eq(true)
     end
   end
@@ -79,21 +81,22 @@ describe Onebox::Engine do
     end
   end
 
-  describe ".template_name" do
-    module ScopeForTemplateName
-      class TemplateNameOnebox
-        include Onebox::Engine
-      end
+end
+
+describe ".onebox_name" do
+  module ScopeForTemplateName
+    class TemplateNameOnebox
+      include Onebox::Engine
     end
+  end
 
-    let(:template_name) { ScopeForTemplateName::TemplateNameOnebox.template_name }
+  let(:onebox_name) { ScopeForTemplateName::TemplateNameOnebox.onebox_name }
 
-    it "should not include the scope" do
-      expect(template_name).not_to include("ScopeForTemplateName", "scopefortemplatename")
-    end
+  it "should not include the scope" do
+    expect(onebox_name).not_to include("ScopeForTemplateName", "scopefortemplatename")
+  end
 
-    it "should not include the word Onebox" do
-      expect(template_name).not_to include("onebox", "Onebox")
-    end
+  it "should not include the word Onebox" do
+    expect(onebox_name).not_to include("onebox", "Onebox")
   end
 end

data/spec/lib/onebox/layout_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+describe Onebox::Layout do
+  let(:cache) { Moneta.new(:Memory, expires: true, serializer: :json) }
+  let(:record) { {} }
+  let(:onebox) { described_class.new("amazon", record, cache) }
+  let(:html) { onebox.to_html }
+
+  describe ".template_path" do
+    let(:template_path) { onebox.template_path }
+
+    before(:each) do
+      Onebox.options.load_paths << "directory_a"
+      Onebox.options.load_paths << "directory_b"
+    end
+
+    context "when template exists in directory_b" do
+      before(:each) do
+        allow_any_instance_of(described_class).to receive(:template?) do |path|
+          path == "directory_b"
+        end
+      end
+
+      it "returns directory_b" do
+        expect(template_path).to eq("directory_b")
+      end
+    end
+
+    context "when template exists in directory_a" do
+      before(:each) do
+        allow_any_instance_of(described_class).to receive(:template?) do |path|
+          path == "directory_a"
+        end
+      end
+
+      it "returns directory_a" do
+        expect(template_path).to eq("directory_a")
+      end
+    end
+
+    context "when template doesn't exist in directory_a or directory_b" do
+      it "returns default path" do
+        expect(template_path).to include("template")
+      end
+    end
+
+    after(:each) do
+      Onebox.options.load_paths.pop(2)
+    end
+  end
+
+  describe "#to_html" do
+    class OneboxEngineLayout
+      include Onebox::Engine
+
+      def data
+        "new content"
+      end
+    end
+
+    it "reads from cache if rendered template is cached" do
+      described_class.new("amazon", record, cache).to_html
+      expect(cache).to receive(:fetch)
+      described_class.new("amazon", record, cache).to_html
+    end
+
+    it "contains layout template" do
+      expect(html).to include(%|class="onebox|)
+    end
+
+    it "contains the view" do
+      record = { link: "foo" }
+      html = described_class.new("amazon", record, cache).to_html
+      expect(html).to include(%|"foo"|)
+    end
+  end
+end

data/spec/lib/onebox/matcher_spec.rb

@@ -1,20 +1,5 @@
 require "spec_helper"
 
 describe Onebox::Matcher do
-  describe "#oneboxed" do
-    it "returns Example onebox when given example url" do
-      matcher = described_class.new("http://example.com")
-      expect(matcher.oneboxed).to be(Onebox::Engine::ExampleOnebox)
-    end
 
-    it "returns Amazon onebox when given amazon url" do
-      matcher = described_class.new("http://amazon.com")
-      expect(matcher.oneboxed).to be(Onebox::Engine::AmazonOnebox)
-    end
-
-    it "returns Flickr onebox when given flickr url" do
-      matcher = described_class.new("http://flickr.com")
-      expect(matcher.oneboxed).to be(Onebox::Engine::FlickrOnebox)
-    end
-  end
 end

data/spec/lib/onebox/preview_spec.rb

@@ -1,23 +1,53 @@
 require "spec_helper"
 
 describe Onebox::Preview do
-  before(:each) { Onebox.defaults.cache.clear }
+
+  before do
+    fake("http://www.amazon.com", response("amazon"))
+    FakeWeb.register_uri(:get, "http://www.amazon.com/404-url", status: 404)
+    FakeWeb.register_uri(:get, "http://www.amazon.com/500-url", status: 500)
+    FakeWeb.register_uri(:get, "http://www.amazon.com/error-url", status: 500)
+    FakeWeb.register_uri(:get, "http://www.amazon.com/timeout-url", exception: Timeout::Error)
+    FakeWeb.register_uri(:get, "http://www.amazon.com/http-error", exception: Net::HTTPError)
+    FakeWeb.register_uri(:get, "http://www.amazon.com/error-connecting", exception: Errno::ECONNREFUSED)
+  end
+
+  let(:preview) { described_class.new("http://www.amazon.com") }
 
   describe "#to_s" do
     it "returns some html if given a valid url" do
-      fake("http://www.example.com", response("example"))
-      preview = described_class.new("http://www.example.com")
-      expect(preview.to_s).to include("Example Domain 1")
+      title = "Knit Noro: Accessories"
+      expect(preview.to_s).to include(title)
+    end
+
+    it "returns an empty string if the resource is missing" do
+      expect(described_class.new("http://www.amazon.com/404-url").to_s).to eq("")
+    end
+
+    it "returns an empty string if the resource returns an error" do
+      expect(described_class.new("http://www.amazon.com/500-url").to_s).to eq("")
+    end
+
+    it "returns an empty string if the resource times out" do
+      expect(described_class.new("http://www.amazon.com/timeout-url").to_s).to eq("")
+    end
+
+    it "returns an empty string if there is an http error" do
+      expect(described_class.new("http://www.amazon.com/http-error").to_s).to eq("")
+    end
+
+    it "returns an empty string if there is an error connecting" do
+      expect(described_class.new("http://www.amazon.com/error-connecting").to_s).to eq("")
+    end
+
+    it "returns an empty string if the url is not valid" do
+      expect(described_class.new('not a url').to_s).to eq("")
     end
-    it "returns an empty string if the resource is not found"
-    it "returns an empty string if the resource fails to load"
-    it "returns an empty string if the url is not valid"
   end
 
   describe "#engine" do
     it "returns an engine" do
-      preview = described_class.new("http://www.example.com")
-      expect(preview.send(:engine)).to be_a(Onebox::Engine)
+      expect(preview.send(:engine)).to be_an(Onebox::Engine)
     end
   end
 end

data/spec/lib/onebox_spec.rb

@@ -2,15 +2,14 @@ require "spec_helper"
 
 describe Onebox do
   describe ".preview" do
+    let(:url) { "http://www.amazon.com" }
     it "creates a cache that responds as expected" do
-      url = "http://www.example.com"
       preview = Onebox.preview(url)
       cache = preview.cache
       expect(cache).to respond_to(:key?, :store, :fetch)
     end
 
     it "stores the value in cache if it doesn't exist" do
-      url = "http://www.example.com"
       preview = Onebox.preview(url)
       preview.to_s
       cache = preview.cache
@@ -18,15 +17,15 @@ describe Onebox do
     end
 
     it "replaces the cache if the cache is expired" do
-      url = "http://www.example.com"
-      preview = Onebox.preview(url, cache: Moneta.new(:Memory, expires: 100000, serializer: :json))
+      preview = Onebox.preview(url, cache: Moneta.new(:Memory, expires: 100_000, serializer: :json))
       cache = preview.cache
       expect(cache.fetch(url)).to be(nil)
     end
   end
 
   describe "templates" do
-    let(:templates) { Dir["templates/*.mustache"] - ["templates/_layout.mustache"] }
+    let(:ignored)  { ["templates/_layout.mustache", "templates/githubgist.mustache"] }
+    let(:templates) { Dir["templates/*.mustache"] - ignored }
 
     def expect_templates_to_not_match(text)
       templates.each do |template|
@@ -34,16 +33,21 @@ describe Onebox do
       end
     end
 
-    it "should not contain any triple braces" do
-      expect_templates_to_not_match(/\{\{\{/)
-    end
-
     it "should not contain any script tags" do
       expect_templates_to_not_match(/<script/)
     end
+  end
+
+  describe 'has_matcher?' do
+    before do
+      Onebox::Engine::WhitelistedGenericOnebox.whitelist = %w(youtube.com)
+    end
+    it "has no matcher for a made up url" do
+      expect(Onebox.has_matcher?("http://wow.com/omg/doge")).to be_false
+    end
 
-    it "should not contain any on*" do
-      expect_templates_to_not_match(/\s*on.+\s*=/)
+    it "has a matcher for a real site" do
+      expect(Onebox.has_matcher?("http://www.youtube.com/watch?v=azaIE6QSMUs")).to be_true
     end
   end
 end

data/spec/spec_helper.rb

@@ -12,20 +12,76 @@ require 'mocha/api'
 require_relative "support/html_spec_helper"
 
 RSpec.configure do |config|
+  config.before(:all) do
+    FakeWeb.allow_net_connect = false
+  end
   config.include HTMLSpecHelper
 end
 
+shared_context "engines" do
+  before(:each) do
+    fake(@uri || @link, response(described_class.onebox_name))
+    @onebox = described_class.new(@link)
+    @html = @onebox.to_html
+    @data = Onebox::Helpers.symbolize_keys(@onebox.send(:data))
+  end
+  before(:each) { Onebox.options.cache.clear }
+
+  let(:onebox) { @onebox }
+  let(:html) { @html }
+  let(:data) { @data }
+  let(:link) { @link }
+
+  def escaped_data(key)
+    CGI.escapeHTML(data[key])
+  end
+end
+
 shared_examples_for "an engine" do
-  it "has engine behavior" do
-    expect(described_class.private_instance_methods).to include(:data, :record, :raw)
+  it "responds to data" do
+    expect(described_class.private_instance_methods).to include(:data)
   end
 
-  it "has implemented the data functionality" do
-    expect { described_class.new(link).send(:data) }.not_to raise_error
+  it "responds to record" do
+    expect(described_class.private_instance_methods).to include(:record)
   end
 
   it "correctly matches the url" do
     onebox = Onebox::Matcher.new(link).oneboxed
     expect(onebox).to be(described_class)
   end
+
+  describe "#data" do
+    it "includes title" do
+      expect(data[:title]).not_to be_nil
+    end
+
+    it "includes link" do
+      expect(data[:link]).not_to be_nil
+    end
+  end
+end
+
+shared_examples_for "a layout engine" do
+  describe "#to_html" do
+    it "includes subname" do
+      expect(html).to include(%|<aside class="onebox #{described_class.onebox_name}">|)
+    end
+
+    it "includes title" do
+      expect(html).to include(escaped_data(:title))
+    end
+
+    it "includes link" do
+      expect(html).to include(%|class="link" href="#{data[:link]}|)
+    end
+
+    it "includes badge" do
+      expect(html).to include(%|<strong class="name">#{data[:badge]}</strong>|)
+    end
+
+    it "includes domain" do
+      expect(html).to include(%|class="domain" href="#{escaped_data(:domain)}|)
+    end
+  end
 end