giphy 0.0.1

data/spec/giphy/configuration_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Giphy::Configuration do
+
+  describe ".configure" do
+    it "allows setting version and api_key values" do
+      Giphy::Configuration.configure do |config|
+        config.version = 'v2'
+        config.api_key = '123qwe'
+      end
+
+      expect(Giphy::Configuration.version).to eq 'v2'
+      expect(Giphy::Configuration.api_key).to eq '123qwe'
+    end
+  end
+
+  describe ".version" do
+    context "when no specific version is configured" do
+      it "returns the default version" do
+        Giphy::Configuration.configure { |g| g.version = nil }
+        expect(Giphy::Configuration.version).to eq 'v1'
+      end
+    end
+  end
+
+  describe ".api_key" do
+    context "when no specific api_key is configured" do
+      it "returns the default api_key" do
+        Giphy::Configuration.configure { |g| g.api_key = nil }
+        expect(Giphy::Configuration.api_key).to eq 'dc6zaTOxFJmzC'
+      end
+    end
+  end
+end

data/spec/giphy/favorite_gif_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Giphy::FavoriteGif do
+  let(:invalid_hash) { {} }
+  let(:valid_hash) do
+    { "gif_id"      => "12HoHdqnDxz5NS",
+      "api_key"     => "dc6zaTOxFJmzC",
+      "tag"         => "fun",
+      "create_date" => "2013-06-21 11:51:46"
+    }
+  end
+
+  before { @klass = Giphy::FavoriteGif }
+
+  it_should_behave_like "a Giphy::SpecialGif"
+
+  describe "#tag" do
+    context "when initialized with a valid hash" do
+      subject { Giphy::FavoriteGif.new(valid_hash) }
+      its(:tag) { should eq "fun" }
+    end
+
+    context "when initialized with an empty/invalid hash" do
+      subject { Giphy::FavoriteGif.new(invalid_hash) }
+      it { expect{ subject.tag }.to raise_error KeyError }
+    end
+  end
+end

data/spec/giphy/flagged_gif_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Giphy::FlaggedGif do
+  let(:invalid_hash) { {} }
+  let(:valid_hash) do
+    { "gif_id"           => "m5QHf0caAwgMw",
+      "api_key"          => "dc6zaTOxFJmzC",
+      "is_inappropriate" => "0",
+      "is_wrong_source"  => "1",
+      "source_corrected" => "",
+      "create_date"      => "2013-08-01 11:27:20"
+    }
+  end
+
+  before { @klass = Giphy::FlaggedGif }
+
+  it_should_behave_like "a Giphy::SpecialGif"
+
+  context "when initialized with a valid hash" do
+    subject { Giphy::FlaggedGif.new(valid_hash) }
+
+    its(:inappropriate?)   { should be_false }
+    its(:wrong_source?)    { should be_true }
+    its(:source_corrected) { should eq "" }
+  end
+
+  context "when initialized with an empty/invalid hash" do
+    subject { Giphy::FlaggedGif.new(invalid_hash) }
+
+    it { expect{ subject.inappropriate? }.to raise_error KeyError }
+    it { expect{ subject.wrong_source? }.to raise_error KeyError }
+    it { expect{ subject.source_corrected }.to raise_error KeyError }
+  end
+end

data/spec/giphy/gif_by_id_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Giphy::GifByID do
+  subject { Giphy::GifByID.new }
+
+  describe "#get" do
+    let(:gif_hash)   { double }
+    let(:gif_object) { double }
+    let(:client)     { double(gif: gif_hash, gifs: [gif_hash, gif_hash]) }
+
+    before do
+      Giphy::Client.stub(new: client)
+      Giphy::Gif.stub(:new).with(gif_hash).and_return(gif_object)
+      Giphy::Gif.stub(:build_batch_from).with([gif_hash, gif_hash]).and_return([gif_object, gif_object])
+    end
+
+    describe "#get" do
+      context "when ids size is zero" do
+        it "raises an ArgumentError and sets its error message" do
+          expect{
+            subject.get([])
+            Giphy::Errors::ArgumentError.should_receive(:new).with('wrong number of arguments (0 for 1...Infinite)')
+          }.to raise_error Giphy::Errors::ArgumentError
+        end
+      end
+
+      context "when ids size is one" do
+        it "returns a gif object" do
+          expect( subject.get(['jJgZWn8Z2z4Bi']) ).to eq gif_object
+        end
+      end
+
+      context "when ids size is greates than one" do
+        it "returns an array of gift objects" do
+          expect( subject.get(['jJgZWn8Z2z4Bi', '3avUsGhmckIYE']) ).to eq [gif_object, gif_object]
+        end
+      end
+    end
+  end
+end

data/spec/giphy/gif_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Giphy::Gif do
+  let(:invalid_hash) { {} }
+  let(:valid_hash) do
+    { "type" => "gif",
+      "id"                   => "Pvbwe3TghH6ko",
+      "url"                  => "http://giphy.com/gifs/Pvbwe3TghH6ko",
+      "bitly_gif_url"        => "http://gph.is/18MZ2ya",
+      "bitly_fullscreen_url" => "http://gph.is/18MZ2yc",
+      "bitly_tiled_url"      => "http://gph.is/18MZ2ye",
+      "embed_url"            => "http://giphy.com/embed/Pvbwe3TghH6ko",
+      "images"               => {
+        "fixed_height"             => {
+          "url"    => "http://media0.giphy.com/media/Pvbwe3TghH6ko/200_d.gif",
+          "width"  => "313",
+          "height" => "200"
+        },
+        "fixed_height_still"       => {
+          "url"    => "http://media0.giphy.com/media/Pvbwe3TghH6ko/200_d.gif",
+          "width"  => "313",
+          "height" => "200"
+        },
+        "fixed_height_downsampled" => {
+          "url"    => "http://media0.giphy.com/media/Pvbwe3TghH6ko/200_d.gif",
+          "width"  => "313",
+          "height" => "200"
+        },
+        "fixed_width"              => {
+          "url"    => "http://media0.giphy.com/media/Pvbwe3TghH6ko/200w_d.gif",
+          "width"  => "200",
+          "height" => "128"
+        },
+        "fixed_width_still"        => {
+          "url"    => "http://media0.giphy.com/media/Pvbwe3TghH6ko/200w_d.gif",
+          "width"  => "200",
+          "height" => "128"
+        },
+        "fixed_width_downsampled"  => {
+          "url"    => "http://media0.giphy.com/media/Pvbwe3TghH6ko/200w_d.gif",
+          "width"  => "200",
+          "height" => "128"
+        },
+        "original" => {
+          "url"    => "http://media0.giphy.com/media/Pvbwe3TghH6ko/giphy.gif",
+          "width"  => "400",
+          "height" => "256",
+          "size"   => "1477042",
+          "frames" => "21"
+        }
+      }
+    }
+  end
+
+  describe ".build_batch_from" do
+    it "creates a Giphy::Gif instance for each array element" do
+      array   = [valid_hash, invalid_hash]
+      subject = Giphy::Gif.build_batch_from(array)
+
+      expect(subject.size).to eq array.size
+
+      subject.each do |special_gif|
+        expect(special_gif).to be_a Giphy::Gif
+      end
+    end
+  end
+
+  context "when iniatialized with a valid hash" do
+    subject { Giphy::Gif.new(valid_hash) }
+
+    its(:id)                   { should eq 'Pvbwe3TghH6ko' }
+    its(:url)                  { should eq URI('http://giphy.com/gifs/Pvbwe3TghH6ko') }
+    its(:bitly_gif_url)        { should eq URI('http://gph.is/18MZ2ya') }
+    its(:bitly_fullscreen_url) { should eq URI('http://gph.is/18MZ2yc') }
+    its(:bitly_tiled_url)      { should eq URI('http://gph.is/18MZ2ye') }
+    its(:embed_url)            { should eq URI('http://giphy.com/embed/Pvbwe3TghH6ko') }
+  end
+
+  context "when initialized with an empty/invalid hash" do
+    subject { Giphy::Gif.new(invalid_hash) }
+
+    it { expect{ subject.id }.to raise_error KeyError }
+    its(:url)                  { should eq URI('') }
+    its(:bitly_gif_url)        { should eq URI('') }
+    its(:bitly_fullscreen_url) { should eq URI('') }
+    its(:bitly_tiled_url)      { should eq URI('') }
+    its(:embed_url)            { should eq URI('') }
+  end
+end

data/spec/giphy/image_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Giphy::Image do
+  subject { Giphy::Image.new(hash) }
+
+  context "when initialized with a valid hash" do
+    let(:hash)  do
+      {"url"    => "http://media0.giphy.com/media/ygsIHxE5xSI4o/original.gif",
+       "width"  => "400",
+       "height" => "292",
+       "size"   => "1013326",
+       "frames" => "11"
+      }
+    end
+
+    its(:url)    { should eq URI("http://media0.giphy.com/media/ygsIHxE5xSI4o/original.gif") }
+    its(:width)  { should eq 400 }
+    its(:height) { should eq 292 }
+    its(:size)   { should eq 1013326 }
+    its(:frames) { should eq 11 }
+  end
+
+  describe "when initialized with an empty/invalid hash" do
+    let(:hash) { {} }
+
+    it { expect{ subject.url }.to raise_error KeyError }
+    it { expect{ subject.width }.to raise_error KeyError }
+    it { expect{ subject.height }.to raise_error KeyError }
+    its(:size) { should eq 0 }
+    its(:frames) { should eq 0 }
+  end
+end

data/spec/giphy/null_image_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Giphy::NullImage do
+  subject { Giphy::NullImage.new }
+
+  its(:url)    { should eq URI('') }
+  its(:width)  { should eq 0 }
+  its(:height) { should eq 0 }
+  its(:size)   { should eq 0 }
+  its(:frames) { should eq 0 }
+end

data/spec/giphy/request_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Giphy::Request do
+  let(:connection)    { double('connection') }
+  let(:get_response)  { double('get_response') }
+  let(:post_response) { double('post_response') }
+
+  before do
+    Faraday.stub(new: connection)
+    Giphy::Configuration.stub(api_key: 'dc6zaTOxFJmzC')
+    Giphy::Configuration.stub(version: 'v1')
+  end
+
+  describe ".get" do
+    it "creates an instance and sends #get to it" do
+      instance = double
+      Giphy::Request.stub(new: instance)
+      instance.stub(:get).with('/path', {}).and_return(get_response)
+      expect(Giphy::Request.get('/path', {})).to eq get_response
+    end
+  end
+
+  describe ".post" do
+    it "creates an instance and sends #post to it" do
+      instance = double
+      Giphy::Request.stub(new: instance)
+      instance.stub(:post).with('/path', {}).and_return(get_response)
+      expect(Giphy::Request.post('/path', {})).to eq get_response
+    end
+  end
+
+  describe "#get" do
+    it "returns the response of doing a get to an API endpoint" do
+      connection.stub(:get).
+        with('/v1/gifs/test', {api_key: 'dc6zaTOxFJmzC', option: 'option'}).
+        and_return(get_response)
+      expect(Giphy::Request.new.get('/test', option: 'option')).to eq get_response
+    end
+  end
+
+  describe "#post" do
+    it "returns the response of doing a post to an API endpoint" do
+      connection.stub(:post).
+        with('/v1/gifs/test', {api_key: 'dc6zaTOxFJmzC', option: 'option'}).
+        and_return(post_response)
+      expect(Giphy::Request.new.post('/test', option: 'option')).to eq post_response
+    end
+  end
+end

data/spec/giphy/response_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Giphy::Response do
+  describe ".build" do
+    it "creates an instance and calls #data on it" do
+      data = double
+      response = double(data: data)
+      Giphy::Response.stub(new: response)
+      expect(Giphy::Response.build({})).to eq data
+    end
+  end
+
+  describe "#data" do
+    let(:response) { double(body: hash) }
+    subject { Giphy::Response.new(response) }
+
+    context "when response contains 'data'" do
+      let(:hash) { {'data' => 'data'} }
+
+      it "returns the 'data' value" do
+        expect(subject.data).to eq 'data'
+      end
+    end
+
+    context "when response does not contain 'data'" do
+      let(:hash) do
+        { 'meta' =>
+          { 'error_type'    => 403,
+            'code'          => 403,
+            'error_message' => 'Forbidden'
+          }
+        }
+      end
+
+      it "raises an error and sets its message" do
+        expect{
+          subject.data
+          Giphy::Errors::API.should_receive(:new).with('403 Forbidden')
+        }.to raise_error Giphy::Errors::API
+      end
+    end
+  end
+end

data/spec/giphy/search_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Giphy::Search do
+  class TestObject ; include Giphy::Search ; end
+
+  subject { TestObject.new }
+
+  let(:client)        { double('client') }
+  let(:client_result) { double('result') }
+  let(:response)      { double('response') }
+  let(:options)       { {option: 'option'} }
+
+  before { Giphy::Client.stub(new: client) }
+
+  describe "#recent" do
+    it "returns a batch of Gifs from the client result" do
+      client.stub(:recent).with(options).and_return(client_result)
+      Giphy::Gif.stub(:build_batch_from).with(client_result).and_return(response)
+      expect(subject.recent(options)).to eq response
+    end
+  end
+
+  describe "#translate" do
+    it "returns a batch of Gifs from the client result" do
+      client.stub(:translate).with('word').and_return(client_result)
+      Giphy::Gif.stub(:build_batch_from).with(client_result).and_return(response)
+      expect(subject.translate('word')).to eq response
+    end
+  end
+
+  describe "#search" do
+    it "returns a batch of Gifs from the client result" do
+      client.stub(:search).with('keyword', options).and_return(client_result)
+      Giphy::Gif.stub(:build_batch_from).with(client_result).and_return(response)
+      expect(subject.search('keyword', options)).to eq response
+    end
+  end
+
+  describe "#flag" do
+    it "returns a new FlaggedGif from the client result" do
+      client.stub(:flag).with('wdsf34df').and_return(client_result)
+      Giphy::FlaggedGif.stub(:new).with(client_result).and_return(response)
+      expect(subject.flag('wdsf34df')).to eq response
+    end
+  end
+
+  describe "#flagged" do
+    it "returns a batch of FlaggedGifs from the client result" do
+      client.stub(flagged: client_result)
+      Giphy::FlaggedGif.stub(:build_batch_from).with(client_result).and_return(response)
+      expect(subject.flagged).to eq response
+    end
+  end
+
+  describe "#favorite" do
+    it "returns a new FavoriteGifs from the client result" do
+      client.stub(:favorite).with('wdsf34df').and_return(client_result)
+      Giphy::FavoriteGif.stub(:new).with(client_result).and_return(response)
+      expect(subject.favorite('wdsf34df')).to eq response
+    end
+  end
+
+  describe "#favorites" do
+    it "returns a batch of FavoriteGifs from the client result" do
+      client.stub(favorites: client_result)
+      Giphy::FavoriteGif.stub(:build_batch_from).with(client_result).and_return(response)
+      expect(subject.favorites).to eq response
+    end
+  end
+
+  describe "#screensaver" do
+    it "returns a new Gif from the client result" do
+      client.stub(:screensaver).with('tag').and_return(client_result)
+      Giphy::Gif.stub(:new).with(client_result).and_return(response)
+      expect(subject.screensaver('tag')).to eq response
+    end
+  end
+
+  describe "#random" do
+    it "returns a new Gif from the client result" do
+      client.stub(random: client_result)
+      Giphy::Gif.stub(:new).with(client_result).and_return(response)
+      expect(subject.random).to eq response
+    end
+  end
+
+  describe "#artists" do
+    it "returns a batch of Artists from the client result" do
+      client.stub(artists: client_result)
+      Giphy::Artist.stub(:build_batch_from).with(client_result).and_return(response)
+      expect(subject.artists).to eq response
+    end
+  end
+
+  describe "#gif_by_artist" do
+    it "returns a batch of Gifs from the client result" do
+      client.stub(:artists).with(username: 'artist_name', option: 'option').and_return(client_result)
+      Giphy::Gif.stub(:build_batch_from).with(client_result).and_return(response)
+      expect(subject.gif_by_artist('artist_name', options)).to eq response
+    end
+  end
+
+  describe "#gif_by_id" do
+    it "returns a batch of Gifs from the client result" do
+      gif_by_id = double
+      Giphy::GifByID.stub(new: gif_by_id)
+      gif_by_id.stub(:get).with(['wdsf34df', 'ydfe779f']).and_return(response)
+      expect(subject.gif_by_id('wdsf34df', 'ydfe779f')).to eq response
+    end
+  end
+end