link_thumbnailer 3.3.2

data/spec/response_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Response do
+  let(:url) { 'https://www.google.co.jp' }
+  let(:page) { ::LinkThumbnailer::Page.new(url, {}) }
+
+  let(:response) do
+    r = ::Net::HTTPSuccess.new('', 200, body_shift_jis)
+    r['Content-Type'] = 'text/html'
+    r.body = body_shift_jis
+    r.instance_variable_set(:@read, true)
+    r
+  end
+
+  let(:instance) { described_class.new(response) }
+
+  let(:body_shift_jis) do
+    File.read(File.expand_path('fixtures/google_shift_jis.html', File.dirname(__FILE__)))
+  end
+
+  let(:body_utf8) do
+    File.read(File.expand_path('fixtures/google_utf8.html', File.dirname(__FILE__)))
+  end
+
+  before do
+    allow(LinkThumbnailer).to receive(:page).and_return(page)
+  end
+
+  describe '#charset' do
+    context 'when charset provided in content-type' do
+      before do
+        response['Content-Type'] = 'text/html; charset=Shift_JIS'
+      end
+
+      it { expect(instance.charset).to eq 'Shift_JIS' }
+    end
+
+    context 'when no charset available in content-type' do
+      it { expect(instance.charset).to eq '' }
+    end
+  end
+
+  describe '#body' do
+    context 'when provide valid charset' do
+      before do
+        response['Content-Type'] = 'text/html; charset=Shift_JIS'
+      end
+
+      it { expect(instance.body).to eq body_utf8 }
+    end
+
+    context 'when provide invalid charset' do
+      before do
+        response['Content-Type'] = 'text/html; charset=Shift-JIS'
+      end
+
+      it { expect(instance.body).to eq body_shift_jis }
+    end
+  end
+end

data/spec/scraper_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Scraper do
+
+  let(:source)    { '' }
+  let(:url)       { 'http://foo.com' }
+  let(:document)  { double('document') }
+  let(:website)   { double('website') }
+  let(:instance)  { described_class.new(source, url) }
+
+  before do
+    allow(instance).to receive(:document).and_return(document)
+    allow(instance).to receive(:website).and_return(website)
+  end
+
+  describe '#call' do
+
+    let(:prefix_1)                { 'prefix_1' }
+    let(:prefix_2)                { 'prefix_2' }
+    let(:scraper_class)           { double('scraper_class') }
+    let(:scraper)                 { double('scraper', call: true) }
+    let(:attributes)              { [:bar] }
+    let(:scrapers)                { [prefix_1, prefix_2] }
+    let(:action)                  { instance.call }
+    let(:config)                  { double(attributes: attributes, scrapers: scrapers) }
+
+    before do
+      allow(instance).to receive(:config).and_return(config)
+    end
+
+    context 'when first one return a result' do
+
+      let(:valid_scraper)     { double('scraper') }
+      let(:not_valid_scraper) { double('scraper') }
+
+      before do
+        expect(website).to                receive(:bar).once.and_return('bar')
+        expect(valid_scraper).to          receive(:call).once.with('bar')
+        expect(not_valid_scraper).to_not  receive(:call).with('bar')
+        expect(scraper_class).to          receive(:new).with(document, website).once.and_return(valid_scraper)
+        expect(instance).to               receive(:scraper_class).with(prefix_1, :bar).and_return(scraper_class)
+      end
+
+      it { expect(action).to eq(website) }
+
+    end
+
+    context 'when first one does not return any result' do
+
+      let(:valid_scraper)     { double('scraper') }
+      let(:not_valid_scraper) { double('scraper') }
+
+      before do
+        expect(website).to            receive(:bar).and_return('', 'bar')
+        expect(valid_scraper).to      receive(:call).once.with('bar')
+        expect(not_valid_scraper).to  receive(:call).once.with('bar')
+        expect(scraper_class).to      receive(:new).with(document, website).and_return(not_valid_scraper, valid_scraper)
+        expect(instance).to           receive(:scraper_class).with(prefix_1, :bar).and_return(scraper_class)
+        expect(instance).to           receive(:scraper_class).with(prefix_2, :bar).and_return(scraper_class)
+      end
+
+      it { expect(action).to eq(website) }
+
+    end
+
+  end
+
+end

data/spec/scrapers/base_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Scrapers::Base do
+
+  let(:document) { double('document') }
+  let(:website)  { LinkThumbnailer::Models::Website.new }
+  let(:instance) { described_class.new(document, website) }
+
+  describe '#call' do
+
+    let(:attr)    { :title }
+    let(:value)   { 'foo' }
+    let(:action)  { instance.call(attr) }
+
+    before do
+      allow(instance).to receive(:value).and_return(value)
+    end
+
+    it { expect { action }.to change { website.title }.from(nil).to(value) }
+
+  end
+
+  describe '#model_class' do
+
+    let(:action) { instance.send(:model_class) }
+
+    before do
+      allow(instance).to receive(:attribute_name).and_return(attr)
+    end
+
+    context 'when internal class exists' do
+
+      let(:attr) { :title }
+
+      it { expect(action).to eq(::LinkThumbnailer::Models::Title) }
+
+    end
+
+    context 'when internal class does not exists' do
+
+      let(:attr) { :foo }
+
+      it { expect { action }.to raise_error(NameError) }
+
+    end
+
+  end
+
+  describe '#modelize' do
+
+    let(:node)        { double('node') }
+    let(:text)        { 'foo' }
+    let(:model_class) { double('model_class') }
+    let(:action)      { instance.send(:modelize, node, text) }
+
+    before do
+      allow(instance).to receive(:model_class).and_return(model_class)
+    end
+
+    it 'instantiates a new model' do
+      expect(model_class).to receive(:new).with(node, text)
+      action
+    end
+
+  end
+
+end

data/spec/scrapers/opengraph/base_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Scrapers::Opengraph::Base do
+
+  let(:node)      { double('node') }
+  let(:document)  { double('document') }
+  let(:instance)  { described_class.new(document) }
+
+  describe '#applicable?' do
+
+    let(:meta)    { [node, node] }
+    let(:action)  { instance.applicable? }
+
+    before do
+      allow(instance).to receive(:meta).and_return(meta)
+    end
+
+    context 'when all node is an opengraph' do
+
+      before do
+        allow(instance).to receive(:opengraph_node?).and_return(true, true)
+      end
+
+      it { expect(action).to be_truthy }
+
+    end
+
+    context 'when any node is an opengraph' do
+
+      before do
+        allow(instance).to receive(:opengraph_node?).and_return(true, false)
+      end
+
+      it { expect(action).to be_truthy }
+
+    end
+
+    context 'when no node is an opengraph' do
+
+      before do
+        allow(instance).to receive(:opengraph_node?).and_return(false, false)
+      end
+
+      it { expect(action).to be_falsey }
+
+    end
+
+  end
+
+  describe '#opengraph_node?' do
+
+    let(:action) { instance.send(:opengraph_node?, node) }
+
+    before do
+      allow(node).to receive(:attribute).with('name').and_return(attribute_from_name)
+    end
+
+    context 'with attribute from name valid' do
+
+      let(:attribute_from_name) { 'og:foo' }
+
+      it { expect(action).to be_truthy }
+
+    end
+
+    context 'with attribute from name not valid' do
+
+      let(:attribute_from_name) { 'foo' }
+
+      before do
+        allow(node).to receive(:attribute).with('property').and_return(attribute_from_property)
+      end
+
+      context 'and attribute from property valid' do
+
+        let(:attribute_from_property) { 'og:bar' }
+
+        it { expect(action).to be_truthy }
+
+      end
+
+      context 'and attribute from property not valid' do
+
+        let(:attribute_from_property) { 'bar' }
+
+        it { expect(action).to be_falsey }
+
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'link_thumbnailer'
+require 'rspec'
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/uri_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::URI do
+
+  let(:uri)       { 'http://foo.com' }
+  let(:instance)  { described_class.new(uri) }
+
+  describe '#valid?' do
+
+    let(:action) { instance.send(:valid?) }
+
+    context 'when bad format' do
+
+      before do
+        allow(instance).to receive(:attribute).and_return("/invalid/path")
+      end
+
+      it { expect(action).to be_falsey }
+
+    end
+
+    context 'when valid format' do
+
+      before do
+        allow(instance).to receive(:attribute).and_return("http://foo.com")
+      end
+
+      it { expect(action).to be_truthy }
+
+    end
+
+  end
+
+  describe '#to_s' do
+
+    let(:action) { instance.to_s }
+
+    it { expect(action).to eq(uri) }
+
+  end
+
+end

data/spec/video_parser_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::VideoParser do
+
+  let(:src)       { 'http://foo.com/foo.swf' }
+  let(:video)     { double(src: src) }
+  let(:parser)    { double('parser') }
+  let(:instance)  { described_class.new(video) }
+
+  before do
+    allow(instance).to receive(:parser).and_return(parser)
+  end
+
+  describe '#id' do
+
+    let(:action) { instance.id }
+
+    context 'when respond to video_id' do
+
+      before do
+        allow(parser).to receive(:video_id).and_return(1)
+      end
+
+      it { expect(action).to eq(parser.video_id) }
+
+    end
+
+    context 'when do not respond to video_id' do
+
+      before do
+        allow(parser).to receive(:video_id).and_raise(NoMethodError)
+      end
+
+      it { expect(action).to be_nil }
+
+    end
+
+  end
+
+  describe '#size' do
+
+    let(:action) { instance.size }
+
+    context 'when respond to width and height' do
+
+      before do
+        allow(parser).to receive(:width).and_return(1)
+        allow(parser).to receive(:height).and_return(1)
+      end
+
+      it { expect(action).to eq([parser.width, parser.height]) }
+
+    end
+
+    context 'when do not respond to width and height' do
+
+      before do
+        allow(parser).to receive(:width).and_raise(NoMethodError)
+        allow(parser).to receive(:height).and_raise(NoMethodError)
+      end
+
+      it { expect(action).to be_empty }
+
+    end
+
+  end
+
+  describe '#duration' do
+
+    let(:action) { instance.duration }
+
+    context 'when respond to duration' do
+
+      before do
+        allow(parser).to receive(:duration).and_return(1)
+      end
+
+      it { expect(action).to eq(parser.duration) }
+
+    end
+
+    context 'when do not respond to duration' do
+
+      before do
+        allow(parser).to receive(:duration).and_raise(NoMethodError)
+      end
+
+      it { expect(action).to be_nil }
+
+    end
+
+  end
+
+  describe '#provider' do
+
+    let(:action) { instance.provider }
+
+    context 'when respond to provider' do
+
+      before do
+        allow(parser).to receive(:provider).and_return(1)
+      end
+
+      it { expect(action).to eq(parser.provider) }
+
+    end
+
+    context 'when do not respond to provider' do
+
+      before do
+        allow(parser).to receive(:provider).and_raise(NoMethodError)
+      end
+
+      it { expect(action).to be_nil }
+
+    end
+
+  end
+
+  describe '#embed_code' do
+
+    let(:action) { instance.embed_code }
+
+    context 'when respond to embed_code' do
+
+      before do
+        allow(parser).to receive(:embed_code).and_return('')
+      end
+
+      it { expect(action).to eq(parser.embed_code) }
+
+    end
+
+    context 'when do not respond to embed_code' do
+
+      before do
+        allow(parser).to receive(:embed_code).and_raise(NoMethodError)
+      end
+
+      it { expect(action).to be_nil }
+
+    end
+
+  end
+
+end