link_thumbnailer 3.3.2

data/spec/image_validator_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::ImageValidator do
+
+  let(:src)       { 'http://foo.com' }
+  let(:image)     { double(src: src) }
+  let(:instance)  { described_class.new(image) }
+
+  describe '#call' do
+
+    let(:action) { instance.call }
+
+    before do
+      allow(instance).to receive(:blacklist_urls).and_return(blacklist_urls)
+    end
+
+    context 'when image url is blacklisted' do
+
+      let(:blacklist_urls) { [src] }
+
+      it { expect(action).to be_falsey }
+
+    end
+
+    context 'when image url is not blacklisted' do
+
+      let(:blacklist_urls) { [] }
+
+      it { expect(action).to be_truthy }
+
+    end
+
+  end
+
+end

data/spec/model_spec.rb

@@ -0,0 +1,27 @@
+# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Model do
+
+  let(:instance) { described_class.new }
+
+  describe '#sanitize' do
+
+    let(:str)     { "foo\r\n" }
+    let(:result)  { "foo" }
+    let(:action)  { instance.send(:sanitize, str) }
+
+    it { expect(action).to eq(result) }
+
+    context "when string includes utf-8 characters" do
+      let(:str) { "中文" }
+
+      it "should keeps those characters" do
+        expect(instance.send(:sanitize, str)).to eq(str)
+      end
+    end
+  end
+
+end

data/spec/models/description_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Models::Description do
+
+  let(:text)      { 'bar' }
+  let(:grader)    { double(call: 0) }
+  let(:node)      { double(text: 'bar') }
+  let(:instance)  { described_class.new(node, text) }
+
+  before do
+    expect(LinkThumbnailer::Grader).to receive(:new).at_least(1).times.and_return(grader)
+  end
+
+  describe '#to_s' do
+
+    let(:action) { instance.to_s }
+
+    it { expect(action).to eq(text) }
+
+  end
+
+  describe '#<=>' do
+
+    let(:another_instance)  { described_class.new(node, text) }
+    let(:probability)       { 0.5 }
+    let(:action)            { instance <=> another_instance }
+
+    before do
+      another_instance.probability = probability
+    end
+
+    context 'when instance probability is lower' do
+
+      before do
+        instance.probability = probability - 0.5
+      end
+
+      it { expect(action).to eq(-1) }
+
+    end
+
+    context 'when instance probability is equal' do
+
+      before do
+        instance.probability = probability
+      end
+
+      it { expect(action).to eq(0) }
+
+    end
+
+    context 'when instance probability is greater' do
+
+      before do
+        instance.probability = probability + 0.5
+      end
+
+      it { expect(action).to eq(1) }
+
+    end
+
+  end
+
+end

data/spec/models/favicon_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Models::Favicon do
+
+  let(:uri)       { URI.parse('http://foo.com') }
+  let(:instance)  { described_class.new(uri) }
+
+  it { expect(instance.to_s).to eq('http://foo.com') }
+
+end

data/spec/models/image_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Models::Image do
+
+  let(:src)       { 'http://foo.com' }
+  let(:instance)  { described_class.new(src) }
+
+  before do
+    stub_request(:get, src).to_return(status: 200, body: '', headers: {})
+  end
+
+  describe '#to_s' do
+
+    let(:action) { instance.to_s }
+
+    it { expect(action).to eq(src) }
+
+  end
+
+  describe '#<=>' do
+
+    let(:other)   { double(size: other_size) }
+    let(:action)  { instance <=> other }
+
+    before do
+      allow(instance).to receive(:size).and_return([20, 20])
+    end
+
+    context 'when other has a smaller image' do
+
+      let(:other_size) { [10, 10] }
+
+      it { expect(action).to eq(-1) }
+
+    end
+
+    context 'when other as identical image size' do
+
+      let(:other_size) { [20, 20] }
+
+      it { expect(action).to eq(0) }
+
+    end
+
+    context 'when other as a bigger image' do
+
+      let(:other_size) { [30, 30] }
+
+      it { expect(action).to eq(1) }
+
+    end
+
+  end
+
+  describe '#valid?' do
+
+    let(:validator) { double }
+    let(:action)    { instance.valid? }
+
+    before do
+      allow(instance).to receive(:validator).and_return(validator)
+    end
+
+    it 'calls validator public method' do
+      expect(validator).to receive(:call)
+      action
+    end
+
+  end
+
+  describe '#as_json' do
+
+    let(:action)  { instance.as_json }
+    let(:size)    { [1, 1] }
+    let(:type)    { 'foo' }
+    let(:result)  {
+      {
+        src:  src,
+        size: size,
+        type: type
+      }
+    }
+
+    before do
+      allow(instance).to receive(:size).and_return(size)
+      allow(instance).to receive(:type).and_return(type)
+    end
+
+    it { expect(action).to eq(result) }
+
+  end
+
+end

data/spec/models/title_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Models::Title do
+
+  let(:node)      { double(text: 'bar') }
+  let(:instance)  { described_class.new(node, text) }
+
+  context 'when text provided' do
+
+    let(:text) { 'foo' }
+
+    it { expect(instance.to_s).to eq(text) }
+
+  end
+
+  context 'when text not provided' do
+
+    let(:text) { nil }
+
+    it { expect(instance.to_s).to eq(node.text) }
+
+  end
+
+end

data/spec/models/video_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Models::Video do
+
+  let(:src)       { 'http://foo.com/foo.swf' }
+  let(:instance)  { described_class.new(src) }
+
+  describe '#to_s' do
+
+    let(:action) { instance.to_s }
+
+    it { expect(action).to eq(src) }
+
+  end
+
+  describe '#as_json' do
+
+    let(:action)      { instance.as_json }
+    let(:id)          { 1 }
+    let(:size)        { [1, 1] }
+    let(:duration)    { 10 }
+    let(:provider)    { 'foo' }
+    let(:embed_code)  { 'bar' }
+    let(:result)      {
+      {
+        id:         id,
+        src:        src,
+        size:       size,
+        duration:   duration,
+        provider:   provider,
+        embed_code: embed_code
+      }
+    }
+
+    before do
+      allow(instance).to receive(:id).and_return(id)
+      allow(instance).to receive(:size).and_return(size)
+      allow(instance).to receive(:duration).and_return(duration)
+      allow(instance).to receive(:provider).and_return(provider)
+      allow(instance).to receive(:embed_code).and_return(embed_code)
+    end
+
+    it { expect(action).to eq(result) }
+
+  end
+
+end

data/spec/models/website_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Models::Website do
+
+  let(:instance) { described_class.new }
+
+  it { expect(instance.images).to be_empty }
+
+  describe '#image=' do
+
+    let(:image)   { double }
+    let(:action)  { instance.image = image }
+
+    before do
+      allow(image).to receive(:valid?).and_return(true)
+    end
+
+    it { expect { action }.to change { instance.images.size }.by(1) }
+
+  end
+
+  describe '#images=' do
+
+    let(:image)   { double }
+    let(:action)  { instance.images = image }
+
+    context 'when image is valid' do
+
+      before do
+        allow(image).to receive(:valid?).and_return(true)
+      end
+
+      it { expect { action }.to change { instance.images.size }.by(1) }
+
+    end
+
+    context 'when image is not valid' do
+
+      before do
+        allow(image).to receive(:valid?).and_return(false)
+      end
+
+      it { expect { action }.to_not change { instance.images.size } }
+
+    end
+
+  end
+
+end

data/spec/page_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Page do
+
+  let(:url)       { 'http://foo.com' }
+  let(:instance)  { described_class.new(url, options) }
+
+  context 'with inline options' do
+
+    let(:options) { { image_limit: 2 } }
+
+    it { expect(instance.config.image_limit).to eq(2) }
+    it { expect(instance.config.user_agent).to eq(LinkThumbnailer.config.user_agent) }
+
+  end
+
+  context 'without inline options' do
+
+    let(:options) { {} }
+
+    it { expect(instance.config.image_limit).to eq(LinkThumbnailer.config.image_limit) }
+    it { expect(instance.config.user_agent).to eq(LinkThumbnailer.config.user_agent) }
+
+  end
+
+end

data/spec/processor_spec.rb

@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LinkThumbnailer::Processor do
+
+  let(:page)      { ::LinkThumbnailer::Page.new(url, {}) }
+  let(:instance)  { described_class.new }
+  let(:url)       { 'http://foo.com' }
+
+  before do
+    allow(LinkThumbnailer).to receive(:page).and_return(page)
+  end
+
+  describe '#call' do
+
+    let(:action) { instance.call(url) }
+
+    context 'when redirect_count is greater than config' do
+
+      it { expect { instance.call(url, 10) } .to raise_error(LinkThumbnailer::RedirectLimit) }
+
+    end
+
+    context 'on no http error' do
+
+      let(:body) { 'foo' }
+
+      before do
+        stub_request(:get, url).to_return(status: 200, body: body, headers: {})
+      end
+
+      it { expect(action).to eq(body) }
+
+    end
+
+    context 'on http error' do
+
+      before do
+        stub_request(:get, url).to_return(status: 500, body: '', headers: {})
+      end
+
+      it { expect { action }.to raise_error(LinkThumbnailer::HTTPError) }
+
+    end
+
+    context 'on http redirection' do
+
+      let(:body) { 'foo' }
+
+      context 'with relative uri' do
+
+        let(:another_url) { '/bar' }
+
+        before do
+          stub_request(:get, url).to_return(status: 300, body: '', headers: { 'Location' => another_url })
+          stub_request(:get, url + another_url).to_return(status: 200, body: body, headers: {})
+        end
+
+        it { expect(action).to eq(body) }
+
+      end
+
+      context 'with absolute uri' do
+
+        let(:another_url) { 'http://bar.com' }
+
+        before do
+          stub_request(:get, url).to_return(status: 300, body: '', headers: { 'Location' => another_url })
+          stub_request(:get, another_url).to_return(status: 200, body: body, headers: {})
+        end
+
+        it { expect(action).to eq(body) }
+
+      end
+
+    end
+
+  end
+
+  describe '#with_valid_url' do
+
+    context 'when valid' do
+
+      before do
+        allow(instance).to receive(:valid_url_format?).and_return(true)
+      end
+
+      it 'yields' do
+        expect(instance).to receive(:with_valid_url).and_yield
+        instance.send(:with_valid_url) {}
+      end
+
+    end
+
+    context 'when not valid' do
+
+      before do
+        allow(instance).to receive(:valid_url_format?).and_return(false)
+      end
+
+      it { expect { instance.send(:with_valid_url) }.to raise_error(LinkThumbnailer::BadUriFormat) }
+
+    end
+
+  end
+
+  describe '#set_http_headers' do
+
+    let(:user_agent)  { 'foo' }
+    let(:headers)     { instance.send(:http).override_headers }
+    let(:action)      { instance.send(:set_http_headers) }
+
+    before do
+      allow(instance).to receive(:user_agent).and_return(user_agent)
+      action
+    end
+
+    it { expect(headers['User-Agent']).to eq(user_agent) }
+
+  end
+
+  describe '#set_http_options' do
+
+    let(:http)    { instance.send(:http) }
+    let(:action)  { instance.send(:set_http_options) }
+
+    describe 'verify_mode' do
+
+      context 'when verify_ssl is true' do
+
+        before do
+          allow(instance).to receive(:ssl_required?).and_return(true)
+          action
+        end
+
+        it { expect(http.verify_mode).to_not eq(::OpenSSL::SSL::VERIFY_NONE) }
+
+      end
+
+      context 'when verify_ssl is not true' do
+
+        before do
+          allow(instance).to receive(:ssl_required?).and_return(false)
+          action
+        end
+
+        it { expect(http.verify_mode).to eq(::OpenSSL::SSL::VERIFY_NONE) }
+
+      end
+
+    end
+
+    describe 'open_timeout' do
+
+      let(:http_open_timeout) { 1 }
+
+      before do
+        allow(instance).to receive(:http_open_timeout).and_return(http_open_timeout)
+        action
+      end
+
+      it { expect(http.open_timeout).to eq(http_open_timeout) }
+
+    end
+
+    describe 'read_timeout' do
+
+      let(:http_read_timeout) { 1 }
+
+      before do
+        allow(instance).to receive(:http_read_timeout).and_return(http_read_timeout)
+        action
+      end
+
+      it { expect(http.read_timeout).to eq(http_read_timeout) }
+
+    end
+  end
+
+  describe '#perform_request' do
+
+    let(:action) { instance.send(:perform_request) }
+    let(:http) { double }
+
+    before do
+      allow(instance).to receive(:http).and_return(http)
+      allow(http).to receive(:request).and_return(response)
+    end
+
+    context 'when http success' do
+
+      let(:code)      { 200 }
+      let(:body)      { 'body' }
+      let(:response)  { ::Net::HTTPSuccess.new('', code, body) }
+
+      before do
+        allow(response).to receive(:body).and_return(body)
+      end
+
+      it { expect(action).to eq(body) }
+
+    end
+
+    context 'when access non-utf8-encoding website' do
+      let(:code) { 200 }
+      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
+      let(:response) do
+        r = ::Net::HTTPSuccess.new('', code, body_shift_jis)
+        r['Content-Type'] = 'text/html'
+        r.body = body_shift_jis
+        r.instance_variable_set(:@read, true)
+        r
+      end
+
+      context 'when http success with valid charset provided in Content-Type' do
+        before { response['Content-Type'] = 'text/html; charset=Shift_JIS' }
+        it { expect(action).to eq body_utf8 }
+      end
+
+      context 'when http success with invalid charset provided in Content-Type' do
+        before { response['Content-Type'] = 'text/html; charset=Shift-JIS' }
+        it { expect(action).to eq body_shift_jis }
+      end
+    end
+
+    context 'when http redirection' do
+
+      let(:code)      { 200 }
+      let(:body)      { 'body' }
+      let(:response)  { ::Net::HTTPRedirection.new('', code, body) }
+      let(:new_url)   { 'http://foo.com/bar' }
+
+      before do
+        allow(instance).to receive(:redirect_count).and_return(0)
+        allow(instance).to receive(:resolve_relative_url).and_return(new_url)
+      end
+
+      it 'calls call method' do
+        expect(instance).to receive(:resolve_relative_url)
+        expect(instance).to receive(:call).with(new_url, instance.redirect_count + 1, {})
+        action
+      end
+
+    end
+
+  end
+
+  describe '#build_absolute_url_for' do
+
+    let(:scheme)        { 'https' }
+    let(:host)          { 'foo.com' }
+    let(:url)           { URI("#{scheme}://#{host}") }
+    let(:relative_url)  { '/bar' }
+    let(:action)        { instance.send(:build_absolute_url_for, relative_url).to_s }
+
+    before do
+      allow(instance).to receive(:url).and_return(url)
+    end
+
+    it { expect(action).to eq("#{scheme}://#{host}#{relative_url}") }
+
+  end
+
+  describe '#redirect_limit' do
+
+    let(:redirect_limit)  { 1 }
+    let(:action)          { instance.send(:redirect_limit) }
+
+    before do
+      instance.config.redirect_limit = redirect_limit
+    end
+
+    it { expect(action).to eq(redirect_limit) }
+
+  end
+
+  describe '#user_agent' do
+
+    let(:user_agent)  { 'foo' }
+    let(:action)      { instance.send(:user_agent) }
+
+    before do
+      instance.config.user_agent = user_agent
+    end
+
+    it { expect(action).to eq(user_agent) }
+
+  end
+
+  describe '#http_open_timeout' do
+
+    let(:http_open_timeout)  { 1 }
+    let(:action)        { instance.send(:http_open_timeout) }
+
+    before do
+      instance.config.http_open_timeout = http_open_timeout
+    end
+
+    it { expect(action).to eq(http_open_timeout) }
+
+  end
+
+  describe '#http_read_timeout' do
+
+    let(:http_read_timeout)  { 1 }
+    let(:action)        { instance.send(:http_read_timeout) }
+
+    before do
+      instance.config.http_read_timeout = http_read_timeout
+    end
+
+    it { expect(action).to eq(http_read_timeout) }
+
+  end
+
+  describe '#ssl_required?' do
+
+    let(:verify_ssl)  { true }
+    let(:action)      { instance.send(:ssl_required?) }
+
+    before do
+      instance.config.verify_ssl = verify_ssl
+    end
+
+    it { expect(action).to eq(verify_ssl) }
+
+  end
+
+  describe '#valid_url_format?' do
+
+    let(:action) { instance.send(:valid_url_format?) }
+
+    context 'when bad format' do
+
+      before do
+        allow(instance).to receive(:url).and_return("http://foo.com")
+      end
+
+      it { expect(action).to be_falsey }
+
+    end
+
+    context 'when valid format' do
+
+      before do
+        allow(instance).to receive(:url).and_return(URI("http://foo.com"))
+      end
+
+      it { expect(action).to be_truthy }
+
+    end
+
+  end
+
+  describe '#too_many_redirections?' do
+
+    let(:action) { instance.send(:too_many_redirections?) }
+
+    context 'when redirect count is greater than redirect limit' do
+
+      before do
+        allow(instance).to receive(:redirect_count).and_return(5)
+        allow(instance).to receive(:redirect_limit).and_return(4)
+      end
+
+      it { expect(action).to be_truthy }
+
+    end
+
+    context 'when redirect count is less than redirect limit' do
+
+      before do
+        allow(instance).to receive(:redirect_count).and_return(4)
+        allow(instance).to receive(:redirect_limit).and_return(5)
+      end
+
+      it { expect(action).to be_falsey }
+
+    end
+
+    context 'when redirect count is equal to redirect limit' do
+
+      before do
+        allow(instance).to receive(:redirect_count).and_return(5)
+        allow(instance).to receive(:redirect_limit).and_return(5)
+      end
+
+      it { expect(action).to be_falsey }
+
+    end
+
+  end
+
+  describe '#url=' do
+
+    before do
+      instance.send(:url=, url)
+    end
+
+    it { expect(instance.url).to be_a(URI) }
+
+  end
+
+end