link_thumbnailer 1.1.2 → 2.0.0

data/spec/models/description_spec.rb

@@ -0,0 +1,64 @@
+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
+    ::LinkThumbnailer::Grader.should_receive(:new).at_least(1).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(:score)             { 5 }
+    let(:action)            { instance <=> another_instance }
+
+    before do
+      another_instance.score = score
+    end
+
+    context 'when instance score is lower' do
+
+      before do
+        instance.score = score - 1
+      end
+
+      it { expect(action).to eq(-1) }
+
+    end
+
+    context 'when instance score is equal' do
+
+      before do
+        instance.score = score
+      end
+
+      it { expect(action).to eq(0) }
+
+    end
+
+    context 'when instance score is greater' do
+
+      before do
+        instance.score = score + 1
+      end
+
+      it { expect(action).to eq(1) }
+
+    end
+
+  end
+
+end

data/spec/models/image_spec.rb

@@ -0,0 +1,71 @@
+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
+      instance.stub(: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
+      instance.stub(:validator).and_return(validator)
+    end
+
+    it 'calls validator public method' do
+      expect(validator).to receive(:call)
+      action
+    end
+
+  end
+
+end

data/spec/models/title_spec.rb

@@ -0,0 +1,24 @@
+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/website_spec.rb

@@ -0,0 +1,49 @@
+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
+      image.stub(: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
+        image.stub(: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
+        image.stub(:valid?).and_return(false)
+      end
+
+      it { expect { action }.to_not change { instance.images.size }.by(1) }
+
+    end
+
+  end
+
+end

data/spec/page_spec.rb

@@ -0,0 +1,26 @@
+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,349 @@
+require 'spec_helper'
+
+describe LinkThumbnailer::Processor do
+
+  let(:instance)  { described_class.new }
+  let(:url)       { 'http://foo.com' }
+
+  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(Net::HTTPFatalError) }
+
+    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
+        instance.stub(: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
+        instance.stub(: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).headers }
+    let(:action)      { instance.send(:set_http_headers) }
+
+    before do
+      instance.stub(: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
+          instance.stub(: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
+          instance.stub(: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_timeout) { 1 }
+
+      before do
+        instance.stub(:http_timeout).and_return(http_timeout)
+        action
+      end
+
+      it { expect(http.open_timeout).to eq(http_timeout) }
+
+    end
+
+  end
+
+  describe '#perform_request' do
+
+    let(:action) { instance.send(:perform_request) }
+
+    before do
+      instance.stub_chain(:http, :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
+        response.stub(:body).and_return(body)
+      end
+
+      it { expect(action).to eq(body) }
+
+    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
+        instance.stub(:redirect_count).and_return(0)
+        instance.stub(: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
+      instance.stub(: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_timeout' do
+
+    let(:http_timeout)  { 1 }
+    let(:action)        { instance.send(:http_timeout) }
+
+    before do
+      instance.config.http_timeout = http_timeout
+    end
+
+    it { expect(action).to eq(http_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
+        instance.stub(:url).and_return("http://foo.com")
+      end
+
+      it { expect(action).to be_false }
+
+    end
+
+    context 'when valid format' do
+
+      before do
+        instance.stub(:url).and_return(URI("http://foo.com"))
+      end
+
+      it { expect(action).to be_true }
+
+    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
+        instance.stub(:redirect_count).and_return(5)
+        instance.stub(:redirect_limit).and_return(4)
+      end
+
+      it { expect(action).to be_true }
+
+    end
+
+    context 'when redirect count is less than redirect limit' do
+
+      before do
+        instance.stub(:redirect_count).and_return(4)
+        instance.stub(:redirect_limit).and_return(5)
+      end
+
+      it { expect(action).to be_false }
+
+    end
+
+    context 'when redirect count is equal to redirect limit' do
+
+      before do
+        instance.stub(:redirect_count).and_return(5)
+        instance.stub(:redirect_limit).and_return(5)
+      end
+
+      it { expect(action).to be_false }
+
+    end
+
+  end
+
+  describe '#url=' do
+
+    before do
+      instance.send(:url=, url)
+    end
+
+    it { expect(instance.url).to be_a(URI) }
+
+  end
+
+end

data/spec/scraper_spec.rb

@@ -0,0 +1,95 @@
+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
+    instance.stub(:document).and_return(document)
+    instance.stub(: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(:applicable_scraper)      { double(applicable?: true) }
+    let(:not_applicable_scraper)  { double(applicable?: false) }
+    let(:attributes)              { [:bar] }
+    let(:scrapers)                { [prefix_1, prefix_2] }
+    let(:action)                  { instance.call }
+
+    before do
+      instance.stub_chain(:config, :attributes).and_return(attributes)
+      instance.stub(:scrapers).and_return(scrapers)
+    end
+
+    context 'when first scraper not applicable' do
+
+      before do
+        expect(website).to            receive(:bar).and_return('bar')
+        expect(applicable_scraper).to receive(:call).with(website, 'bar')
+        expect(scraper_class).to      receive(:new).with(document).and_return(applicable_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 scraper applicable' do
+
+      before do
+        expect(website).to                    receive(:bar).and_return('bar')
+        expect(not_applicable_scraper).to_not receive(:call).with(website, 'bar')
+        expect(scraper_class).to              receive(:new).with(document).and_return(not_applicable_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 all scrapers applicable and first one return a result' do
+
+      let(:valid_scraper)     { double('scraper', applicable?: true) }
+      let(:not_valid_scraper) { double('scraper', applicable?: true) }
+
+      before do
+        expect(website).to                receive(:bar).once.and_return('bar')
+        expect(valid_scraper).to          receive(:call).once.with(website, 'bar')
+        expect(not_valid_scraper).to_not  receive(:call).with(website, 'bar')
+        expect(scraper_class).to          receive(:new).with(document).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 all scrapers applicable but first one do not return any result' do
+
+      let(:valid_scraper)     { double('scraper', applicable?: true) }
+      let(:not_valid_scraper) { double('scraper', applicable?: true) }
+
+      before do
+        expect(website).to            receive(:bar).and_return('', 'bar')
+        expect(valid_scraper).to      receive(:call).once.with(website, 'bar')
+        expect(not_valid_scraper).to  receive(:call).once.with(website, 'bar')
+        expect(scraper_class).to      receive(:new).with(document).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