jekyll-twitter-plugin 1.4.0 → 2.0.0

data/spec/api_request_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+RSpec.describe TwitterJekyll::ApiRequest do
+  subject(:api_request) { described_class.new(url, params) }
+  let(:url) { "https://twitter.com/twitter_user/status/12345" }
+  let(:params) { {} }
+
+  describe "#to_uri" do
+    subject(:uri) { api_request.to_uri }
+
+    it "uses correct api" do
+      expect(uri.scheme).to eq "https"
+      expect(uri.host).to eq "publish.twitter.com"
+      expect(uri.path).to eq "/oembed"
+    end
+
+    context "with no params" do
+      it "has url encoded query param" do
+        expect(URI.decode_www_form(uri.query)).to match_array [["url", url]]
+      end
+    end
+
+    context "with params" do
+      let(:params) { { align: "right" } }
+
+      it "has encoded query params" do
+        expect(URI.decode_www_form(uri.query)).to match_array [["url", url], %w(align right)]
+      end
+    end
+
+    context "with an incorrectly passed url param" do
+      let(:params) { { url: "why" } }
+
+      it "has uses the correct url" do
+        expect(URI.decode_www_form(uri.query)).to match_array [["url", url]]
+      end
+    end
+  end
+
+  describe "#cache_key" do
+    let(:url) { ["https://twitter.com/twitter_user/status/12345"] }
+
+    context "with no params" do
+      it "matches on status url" do
+        request_one = described_class.new(url, {})
+        request_two = described_class.new(url, {})
+
+        expect(
+          request_one.cache_key == request_two.cache_key
+        ).to be true
+      end
+
+      it "fails if different" do
+        request_one = described_class.new(url, {})
+        request_two = described_class.new("https://twitter.com/other_user/status/12345", {})
+
+        expect(
+          request_one.cache_key == request_two.cache_key
+        ).to be false
+      end
+    end
+
+    context "with params" do
+      it "matches on keys and values" do
+        request_one = described_class.new(url, align: "left")
+        request_two = described_class.new(url, align: "left")
+
+        expect(
+          request_one.cache_key == request_two.cache_key
+        ).to be true
+      end
+
+      it "fails if different" do
+        request_one = described_class.new(url, align: "left")
+        request_two = described_class.new(url, align: "right")
+
+        expect(
+          request_one.cache_key == request_two.cache_key
+        ).to be false
+      end
+    end
+  end
+end

data/spec/integration_tests.rb

@@ -7,13 +7,20 @@ $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
 require_relative "./support/jekyll_template"
 require "jekyll-twitter-plugin"
 require "erb"
+require "byebug"
 
 OUTPUT_FILENAME = "output_test.html"
 OPTIONS = [
-  "oembed https://twitter.com/rubygems/status/518821243320287232",
-  "oembed https://twitter.com/rubygems/status/518821243320287232 align='right' width='350'",
+  "https://twitter.com/jekyllrb maxwidth=500 limit=5",
+  "https://twitter.com/rubygems",
+  "https://twitter.com/i/moments/650667182356082688 maxwidth=500",
+  "https://twitter.com/TwitterDev/timelines/539487832448843776 limit=5 widget_type=grid maxwidth=500",
   "https://twitter.com/rubygems/status/518821243320287232",
-  "oembed https://twitter.com/rubygems/status/missing"
+  "https://twitter.com/rubygems/status/11",
+  "https://twitter.com/rubygems/status/518821243320287232 align=right width=350",
+  "https://twitter.com/Ace_Tate/status/225611299009216512",
+  "https://twitter.com/FeelsGood2BeMe/status/225456333032398848",
+  "oembed https://twitter.com/rubygems/status/518821243320287232",
 ].freeze
 
 COLOUR_MAP = {

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "webmock/rspec"
 require "support/jekyll_template"
 require "support/shared_contexts"
 require "jekyll-twitter-plugin"

data/spec/support/shared_contexts.rb

@@ -11,11 +11,12 @@ RSpec.shared_context "without cached response" do
   end
 end
 
-RSpec.shared_context "with any oembed request and response" do
-  let(:options) { "oembed https://twitter.com/twitter_user/status/12345" }
-  let(:response) { OpenStruct.new(html: "<p>tweet html</p>") }
+RSpec.shared_context "with a normal request and response" do
+  let(:arguments) { "https://twitter.com/twitter_user/status/12345" }
+  let(:response) { { html: "<p>tweet html</p>" } }
 
   before do
-    allow(api_client).to receive(:oembed).and_return(response)
+    allow(api_client).to receive(:fetch).and_return(response)
+    allow(TwitterJekyll::ApiClient).to receive(:new).and_return(api_client)
   end
 end

data/spec/twitter_tag_spec.rb

@@ -1,26 +1,26 @@
 # frozen_string_literal: true
 RSpec.describe TwitterJekyll::TwitterTag do
-  let(:context) { double.as_null_object }
-  let(:options) { "" }
-  subject { described_class.new(nil, options, nil) }
+  let(:context) { empty_jekyll_context }
+  let(:arguments) { "" }
+  let(:api_response_hash) do
+    {
+      "url" => "https://twitter.com/twitter_user/status/12345",
+      "author_name" => "twitter user",
+      "author_url" => "https://twitter.com/twitter_user",
+      "html" => "<p>tweet html</p>",
+      "width" => 550,
+      "height" => nil,
+      "type" => "rich",
+      "cache_age" => "3153600000",
+      "provider_name" => "Twitter",
+      "provider_url" => "https://twitter.com",
+      "version" => "1.0"
+    }
+  end
+  subject { described_class.new(nil, arguments, nil) }
 
   describe "output from oembed request" do
-    let(:api_response_hash) do
-      {
-        "url" => "https://twitter.com/twitter_user/status/12345",
-        "author_name" => "twitter user",
-        "author_url" => "https://twitter.com/twitter_user",
-        "html" => "<p>tweet html</p>",
-        "width" => 550,
-        "height" => nil,
-        "type" => "rich",
-        "cache_age" => "3153600000",
-        "provider_name" => "Twitter",
-        "provider_url" => "https://twitter.com",
-        "version" => "1.0"
-      }
-    end
-    let(:options) { "oembed https://twitter.com/twitter_user/status/12345" }
+    let(:arguments) { "https://twitter.com/twitter_user/status/12345" }
 
     context "with cached response" do
       let(:cache) { double("TwitterJekyll::FileCache") }
@@ -29,7 +29,6 @@ RSpec.describe TwitterJekyll::TwitterTag do
       end
 
       it "renders response from cache" do
-        allow(Twitter::REST::Client).to receive(:new).and_return(double.as_null_object)
         expect(cache).to receive(:read).with(an_instance_of(String)).and_return(api_response_hash)
 
         output = subject.render(context)
@@ -39,19 +38,18 @@ RSpec.describe TwitterJekyll::TwitterTag do
 
     context "without cached response" do
       let(:cache) { double("TwitterJekyll::FileCache") }
-      let(:response) { build_response_object(api_response_hash) }
       before do
         subject.cache = cache
         allow(cache).to receive(:read).with(an_instance_of(String)).and_return(nil)
       end
 
       context "with successful api request" do
-        it "renders response from api and writes to cache" do
-          api_client = double("Twitter::REST::Client", status: double)
-          allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+        before do
+          stub_api_request(status: 200, body: api_response_hash.to_json, headers: {})
+        end
 
-          expect(api_client).to receive(:oembed).and_return(response)
-          expect(cache).to receive(:write).with(an_instance_of(String), response)
+        it "renders response from api and writes to cache" do
+          expect(cache).to receive(:write).with(an_instance_of(String), api_response_hash)
 
           output = subject.render(context)
           expect_output_to_match_tag_content(output, api_response_hash.fetch("html"))
@@ -59,107 +57,106 @@ RSpec.describe TwitterJekyll::TwitterTag do
       end
 
       context "with a status not found api request" do
-        it "renders response from api and does not write to cache" do
-          api_client = double("Twitter::REST::Client", status: double)
-          allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+        before do
+          stub_api_request(status: [404, "Not Found"], body: "", headers: {})
+        end
 
-          expect(api_client).to receive(:status).and_raise(Twitter::Error::NotFound)
-          expect(cache).not_to receive(:write).with(an_instance_of(String), response)
+        it "renders error response and writes to cache" do
+          expect(cache).to receive(:write).with(an_instance_of(String), an_instance_of(Hash))
 
           output = subject.render(context)
-          expect_output_to_have_error(output, Twitter::Error::NotFound)
+          expect_output_to_have_error(output, "Not Found")
         end
       end
 
       context "with a status request not permitted api request" do
-        it "renders response from api and does not write to cache" do
-          api_client = double("Twitter::REST::Client", status: double)
-          allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+        before do
+          stub_api_request(status: [403, "Forbidden"], body: "", headers: {})
+        end
 
-          expect(api_client).to receive(:status).and_raise(Twitter::Error::Forbidden)
-          expect(cache).not_to receive(:write).with(an_instance_of(String), response)
+        it "renders error response and writes to cache" do
+          expect(cache).to receive(:write).with(an_instance_of(String), an_instance_of(Hash))
 
           output = subject.render(context)
-          expect_output_to_have_error(output, Twitter::Error::Forbidden)
+          expect_output_to_have_error(output, "Forbidden")
         end
       end
-    end
-  end
 
-  describe "With an invalid request type" do
-    context "without any arguments" do
-      let(:options) { "" }
+      context "with a server error api request" do
+        before do
+          stub_api_request(status: [500, "Internal Server Error"], body: "", headers: {})
+        end
 
-      it "raises an exception" do
-        expect_to_raise_invalid_args_error(options) do
-          tag = described_class.new(nil, options, nil)
-          tag.render(context)
+        it "renders error response and writes to cache" do
+          expect(cache).to receive(:write).with(an_instance_of(String), an_instance_of(Hash))
+
+          output = subject.render(context)
+          expect_output_to_have_error(output, "Internal Server Error")
         end
       end
-    end
 
-    context "with an api request type not supported" do
-      let(:options) { "unsupported https://twitter.com/twitter_user/status/12345" }
+      context "with api request that times out" do
+        before do
+          stub_api.to_timeout
+        end
 
-      it "raises an exception" do
-        expect_to_raise_invalid_args_error(options) do
-          tag = described_class.new(nil, options, nil)
-          tag.render(context)
+        it "renders error response and writes to cache" do
+          expect(cache).to receive(:write).with(an_instance_of(String), an_instance_of(Hash))
+
+          output = subject.render(context)
+          expect_output_to_have_error(output, "Timeout::Error")
         end
       end
-    end
 
-    context "without an api request type and no valid status url" do
-      let(:options) { "https://anything.com/twitter_user/status/12345" }
+      context "with the oembed api type as the first argument" do
+        let(:arguments) { "oembed https://twitter.com/twitter_user/status/12345" }
+        before do
+          stub_api_request(status: 200, body: api_response_hash.to_json, headers: {})
+        end
 
-      it "raises an exception" do
-        expect_to_raise_invalid_args_error(options) do
-          tag = described_class.new(nil, options, nil)
-          tag.render(context)
+        it "renders response from api and writes to cache" do
+          expect(cache).to receive(:write).with(an_instance_of(String), api_response_hash)
+
+          output = subject.render(context)
+          expect_output_to_match_tag_content(output, api_response_hash.fetch("html"))
         end
       end
     end
   end
 
-  describe "parsing api request type" do
-    include_context "without cached response"
-    let(:response) { OpenStruct.new(html: "anything") }
-    let(:status) { double }
-
-    context "with oembed requested" do
-      let(:options) { "oembed https://twitter.com/twitter_user/status/12345" }
-
-      it "uses the oembed api" do
-        api_client = double("Twitter::REST::Client", status: status)
-        allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+  describe "parsing arguments" do
+    context "without any arguments" do
+      let(:arguments) { "" }
 
-        expect(api_client).to receive(:oembed).with(status, {}).and_return(response)
-        subject.render(context)
+      it "raises an exception" do
+        expect_to_raise_invalid_args_error(arguments) do
+          tag = described_class.new(nil, arguments, nil)
+          tag.render(context)
+        end
       end
     end
 
-    context "without an api request type" do
-      let(:options) { "https://twitter.com/twitter_user/status/12345" }
+    context "with the oembed api type as the first argument" do
+      let(:arguments) { "oembed https://twitter.com/twitter_user/status/12345" }
 
-      it "uses the default oembed api type" do
-        api_client = double("Twitter::REST::Client", status: status)
-        allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+      it "uses correct twitter url and warns of deprecation" do
+        api_client = api_client_double
+        allow(api_client).to receive(:fetch).and_return({})
+        allow(TwitterJekyll::ApiClient).to receive(:new).and_return(api_client)
+        expect(TwitterJekyll::ApiRequest).to receive(:new).with("https://twitter.com/twitter_user/status/12345", {}).and_call_original
 
-        expect(api_client).to receive(:oembed).with(status, {}).and_return(response)
-        subject.render(context)
+        expect do
+          tag = described_class.new(nil, arguments, nil)
+          tag.render(context)
+        end.to output(/Passing 'oembed' as the first argument is not required anymore/).to_stderr
       end
     end
   end
 
   describe "parsing api secrets" do
     include_context "without cached response"
-    include_context "with any oembed request and response"
-    let(:api_client) { double("Twitter::REST::Client", status: double) }
-    let(:config_builder) { double }
-
-    before do
-      allow(Twitter::REST::Client).to receive(:new).and_yield(config_builder).and_return(api_client)
-    end
+    include_context "with a normal request and response"
+    let(:api_client) { api_client_double }
 
     context "with api secrets provided by ENV" do
       let(:context) { double("context", registers: { site: double(config: {}) }) }
@@ -170,13 +167,11 @@ RSpec.describe TwitterJekyll::TwitterTag do
                           "TWITTER_ACCESS_TOKEN_SECRET" => "access_token_secret")
       end
 
-      it "creates api client correctly" do
-        expect(config_builder).to receive(:consumer_key=).with("consumer_key")
-        expect(config_builder).to receive(:consumer_secret=).with("consumer_secret")
-        expect(config_builder).to receive(:access_token=).with("access_token")
-        expect(config_builder).to receive(:access_token_secret=).with("access_token_secret")
-
-        subject.render(context)
+      it "warns of deprecation" do
+        expect do
+          tag = described_class.new(nil, arguments, nil)
+          tag.render(context)
+        end.to output(/Found Twitter API keys in ENV, this library does not require these keys anymore/).to_stderr
       end
     end
 
@@ -191,40 +186,55 @@ RSpec.describe TwitterJekyll::TwitterTag do
         stub_const("ENV", {})
       end
 
-      it "creates api client correctly" do
-        expect(config_builder).to receive(:consumer_key=).with("consumer_key")
-        expect(config_builder).to receive(:consumer_secret=).with("consumer_secret")
-        expect(config_builder).to receive(:access_token=).with("access_token")
-        expect(config_builder).to receive(:access_token_secret=).with("access_token_secret")
-
-        subject.render(context)
+      it "warns of deprecation" do
+        expect do
+          tag = described_class.new(nil, arguments, nil)
+          tag.render(context)
+        end.to output(/Found Twitter API keys in Jekyll _config.yml, this library does not require these keys anymore/).to_stderr
       end
     end
 
     context "with no api secrets provided" do
-      let(:context) { double("context", registers: { site: double(config: {}) }) }
+      let(:context) { empty_jekyll_context }
       before do
         stub_const("ENV", {})
       end
 
-      it "raises an exception" do
+      it "does not warn" do
         expect do
           subject.render(context)
-        end.to raise_error(TwitterJekyll::MissingApiKeyError)
+        end.to_not output.to_stderr
       end
     end
   end
 
   private
 
+  def stub_api_request(response)
+    stub_api
+      .to_return(response)
+  end
+
+  def stub_api
+    stub_request(:get, /publish.twitter.com/)
+  end
+
+  def empty_jekyll_context
+    double("context", registers: { site: double(config: {}) })
+  end
+
+  def api_client_double
+    double("TwitterJekyll::ApiClient")
+  end
+
   def expect_output_to_match_tag_content(actual, content)
     expect(actual).to eq(
-      "<div class='embed twitter'>#{content}</div>"
+      "<div class='jekyll-twitter-plugin'>#{content}</div>"
     )
   end
 
   def expect_output_to_have_error(actual, error, tweet_url = "https://twitter.com/twitter_user/status/12345")
-    expect_output_to_match_tag_content(actual, "<p>There was a '#{error}' error fetching Tweet '#{tweet_url}'</p>")
+    expect_output_to_match_tag_content(actual, "<p>There was a '#{error}' error fetching URL: '#{tweet_url}'</p>")
   end
 
   def expect_to_raise_invalid_args_error(options)
@@ -235,9 +245,4 @@ RSpec.describe TwitterJekyll::TwitterTag do
       yield
     end.to raise_error(ArgumentError, message)
   end
-
-  # The twitter gem responds with a struct like object so we do too.
-  def build_response_object(response)
-    OpenStruct.new(response)
-  end
 end