doomy_client 0.8.5

data/lib/tumblr/version.rb

@@ -0,0 +1,5 @@
+module Tumblr
+
+  VERSION = '0.8.5'
+
+end

data/lib/tumblr_client.rb

@@ -0,0 +1,16 @@
+require 'tumblr/client'
+require 'tumblr/config'
+
+module Tumblr
+
+  autoload :VERSION, File.join(File.dirname(__FILE__), 'tumblr/version')
+
+  extend Config
+
+  class << self
+    def new(options={})
+      Tumblr::Client.new(options)
+    end
+  end
+
+end

data/spec/examples/blog_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe Tumblr::Blog do
+
+  let(:blog_name) { 'seejohnrun.tumblr.com' }
+  let(:consumer_key) { 'ckey' }
+  let(:client) do
+    Tumblr::Client.new :consumer_key => consumer_key
+  end
+
+  describe :blog_info do
+
+    it 'should make the proper request' do
+      expect(client).to receive(:get).once.with("v2/blog/#{blog_name}/info", {
+        :api_key => consumer_key
+      }).and_return 'response'
+      r = client.blog_info blog_name
+      expect(r).to eq('response')
+    end
+
+    it 'should make the proper request with a short blog name' do
+      expect(client).to receive(:get).once.with("v2/blog/b.tumblr.com/info", {
+        :api_key => consumer_key
+      }).and_return 'response'
+      r = client.blog_info 'b'
+      expect(r).to eq('response')
+    end
+
+  end
+
+  describe :avatar do
+
+    context 'when supplying a size' do
+
+      before do
+        expect(client).to receive(:get_redirect_url).once.with("v2/blog/#{blog_name}/avatar/128").
+        and_return('url')
+      end
+
+      it 'should construct the request properly' do
+        r = client.avatar blog_name, 128
+        expect(r).to eq('url')
+      end
+
+    end
+
+    context 'when no size is specified' do
+
+      before do
+        expect(client).to receive(:get_redirect_url).once.with("v2/blog/#{blog_name}/avatar").
+        and_return('url')
+      end
+
+      it 'should construct the request properly' do
+        r = client.avatar blog_name
+        expect(r).to eq('url')
+      end
+
+    end
+
+  end
+
+  describe :followers do
+
+    context 'with invalid parameters' do
+
+      it 'should raise an error' do
+        expect(lambda {
+          client.followers blog_name, :not => 'an option'
+        }).to raise_error ArgumentError
+      end
+
+    end
+
+    context 'with valid parameters' do
+
+      before do
+        expect(client).to receive(:get).once.with("v2/blog/#{blog_name}/followers", {
+          :limit => 1
+        }).and_return('response')
+      end
+
+      it 'should construct the request properly' do
+        r = client.followers blog_name, :limit => 1
+        expect(r).to eq'response'
+      end
+
+    end
+
+  end
+
+  describe :blog_likes do
+
+    context 'with invalid parameters' do
+
+      it 'should raise an error' do
+        expect(lambda {
+          client.blog_likes blog_name, :not => 'an option'
+        }).to raise_error ArgumentError
+      end
+
+    end
+
+    context 'with valid parameters' do
+
+      before do
+        expect(client).to receive(:get).once.with("v2/blog/#{blog_name}/likes", {
+          :limit => 1,
+          :api_key => consumer_key
+        }).and_return('response')
+      end
+
+      it 'should construct the request properly' do
+        r = client.blog_likes blog_name, :limit => 1
+        expect(r).to eq('response')
+      end
+
+    end
+
+  end
+
+  describe :posts do
+
+    context 'without a type supplied' do
+
+      before do
+        expect(client).to receive(:get).once.with("v2/blog/#{blog_name}/posts", {
+          :limit => 1,
+          :api_key => consumer_key
+        }).and_return('response')
+      end
+
+      it 'should construct the request properly' do
+        r = client.posts blog_name, :limit => 1
+        expect(r).to eq('response')
+      end
+
+    end
+
+    context 'when supplying a type' do
+
+      before do
+        expect(client).to receive(:get).once.with("v2/blog/#{blog_name}/posts/audio", {
+          :limit => 1,
+          :api_key => consumer_key,
+          :type => 'audio'
+        }).and_return('response')
+      end
+
+      it 'should construct the request properly' do
+        r = client.posts blog_name, :limit => 1, :type => 'audio'
+        expect(r).to eq('response')
+      end
+
+    end
+
+  end
+
+  # These are all just lists of posts with pagination
+  [:queue, :draft, :submissions].each do |type|
+
+    ext = type == :submissions ? 'submission' : type.to_s # annoying
+
+    describe type do
+
+      context 'when using parameters other than limit & offset' do
+
+        it 'should raise an error' do
+          expect(lambda {
+            client.send type, blog_name, :not => 'an option'
+          }).to raise_error ArgumentError
+        end
+
+      end
+
+      context 'with valid options' do
+
+        it 'should construct the call properly' do
+          limit = 5
+          expect(client).to receive(:get).once.with("v2/blog/#{blog_name}/posts/#{ext}", {
+            :limit => limit
+          }).and_return('response')
+          r = client.send type, blog_name, :limit => limit
+          expect(r).to eq('response')
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/examples/client_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Tumblr::Client do
+
+  context 'when using the generic copy' do
+
+    before do
+      @key = 'thekey'
+      Tumblr.configure do |c|
+        c.consumer_key = @key
+      end
+    end
+
+    it 'should give new clients those credentials' do
+      client = Tumblr::Client.new
+      expect(client.credentials[:consumer_key]).to eq(@key)
+    end
+
+    it 'should have it\'s own credentials' do
+      expect(Tumblr.credentials[:consumer_key]).to eq(@key)
+    end
+
+    it 'should be able to make a new client (using these credentials)' do
+      expect(Tumblr.new).to be_a(Tumblr::Client)
+      expect(Tumblr.new.credentials[:consumer_key]).to eq(@key)
+    end
+
+  end
+
+  context 'when using custom copies of the client' do
+
+    before do
+      @client1 = Tumblr::Client.new(:consumer_key => 'key1')
+      @client2 = Tumblr::Client.new(:consumer_key => 'key2')
+    end
+
+    it 'should keep them separate' do
+      expect([
+        @client1.credentials[:consumer_key],
+        @client2.credentials[:consumer_key]
+      ].uniq.count).to eq(2)
+    end
+
+  end
+
+  describe :api_scheme do
+
+    it 'defaults to https' do
+      expect(Tumblr::Client.new.api_scheme).to eq('https')
+    end
+
+    it 'can be set by the initializer' do
+      client = Tumblr::Client.new(:api_scheme => 'http')
+      expect(client.api_scheme).to eq('http')
+    end
+
+    it 'can be set globally' do
+      Tumblr.configure do |c|
+        c.api_scheme = 'http'
+      end
+      expect(Tumblr::Client.new.api_scheme).to eq('http')
+    end
+
+  end
+
+end

data/spec/examples/post_spec.rb

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+describe Tumblr::Post do
+
+  let(:client) { Tumblr::Client.new }
+  let(:blog_name) { 'blog.name' }
+  let(:file_path) { '/path/to/the/file' }
+  let(:file_data) { 'lol cats' }
+  let(:source)    { 'the source' }
+  let(:post_id)   { 42 }
+
+  describe :delete do
+
+    context 'when deleting a post' do
+
+      before do
+        expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post/delete", {
+          :id => post_id
+        })
+      end
+
+      it 'should setup a delete properly' do
+        client.delete blog_name, post_id
+      end
+
+    end
+
+  end
+
+  describe :edit do
+    [:photo, :audio, :video].each do |type|
+      describe type do
+        context 'when passing data as an array of filepaths' do
+          before do
+            fakefile = OpenStruct.new :read => file_data
+            allow(File).to receive(:open).with(file_path + '.jpg').and_return(fakefile)
+            expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post/edit", {
+              'data[0]' => kind_of(Faraday::UploadIO),
+                :id => 123,
+                :type => type
+            }).and_return('response')
+          end
+
+          it 'should be able to pass data as an array of filepaths' do
+            r = client.edit blog_name, :data => [file_path + ".jpg"], :id => 123, :type => type
+            expect(r).to eq('response')
+          end
+
+          it 'should be able to pass data as an array of uploadios' do
+            r = client.edit blog_name, :data => [Faraday::UploadIO.new(StringIO.new, 'image/jpeg')], :id => 123, :type => type
+            expect(r).to eq('response')
+          end
+
+        end
+
+        context 'when passing data different ways' do
+
+          before do
+            fakefile = OpenStruct.new :read => file_data
+            allow(File).to receive(:open).with(file_path + '.jpg').and_return(fakefile)
+            expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post/edit", {
+              'data' => kind_of(Faraday::UploadIO),
+                :id => 123,
+                :type => type
+            }).and_return('response')
+          end
+
+          it 'should be able to pass data as a single filepath' do
+            r = client.edit blog_name, :data => file_path + ".jpg", :id => 123, :type => type
+            expect(r).to eq('response')
+          end
+
+          it 'should be able to pass data as a single uploadio' do
+            r = client.edit blog_name, :data => Faraday::UploadIO.new(StringIO.new, 'image/jpeg'), :id => 123, :type => type
+            expect(r).to eq('response')
+          end
+
+        end
+      end
+    end
+
+    it 'should make the correct call' do
+      expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post/edit", {
+        :id => 123
+      }).and_return('response')
+      r = client.edit blog_name, :id => 123
+      expect(r).to eq('response')
+    end
+  end
+
+  describe :reblog do
+
+    it 'should make the correct call' do
+      expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post/reblog", {
+        :id => 123
+      }).and_return('response')
+      r = client.reblog blog_name, :id => 123
+      expect(r).to eq('response')
+    end
+
+  end
+
+  # Simple post types
+  [:quote, :text, :link, :chat].each do |type|
+
+    field = type == :quote ? 'quote' : 'title' # uglay
+
+    describe type do
+
+      context 'when passing an option which is not allowed' do
+
+        it 'should raise an error' do
+          expect(lambda {
+            client.send type, blog_name, :not => 'an option'
+          }).to raise_error ArgumentError
+        end
+
+      end
+
+      context 'when passing valid data' do
+
+        before do
+          @val = 'hello world'
+          expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post", {
+            field.to_sym => @val,
+            :type => type.to_s
+          }).and_return('response')
+        end
+
+        it 'should set up the call properly' do
+          r = client.send type, blog_name, field.to_sym => @val
+          expect(r).to eq('response')
+        end
+
+      end
+
+    end
+
+  end
+
+  describe :create_post do
+
+    let(:blog_name) { 'seejohnrun' }
+    let(:args) { { :source => 'somesource' } }
+
+    context 'with a valid post type' do
+
+      before do
+        expect(client).to receive(:photo).with(blog_name, args).and_return 'hi'
+      end
+
+      it 'should call the right method and grab the return' do
+        expect(client.create_post(:photo, blog_name, args)).to eq('hi')
+      end
+
+    end
+
+    context 'with an invalid post type' do
+
+      it 'should raise an error' do
+        expect(lambda do
+          client.create_post(:fake, blog_name, args)
+        end).to raise_error ArgumentError, '"fake" is not a valid post type'
+      end
+
+    end
+
+  end
+
+  # Complex post types
+  [:photo, :audio, :video].each do |type|
+
+    describe type do
+
+      context 'when passing an option which is not allowed' do
+
+        it 'should raise an error' do
+          expect(lambda {
+            client.send type, blog_name, :not => 'an option'
+          }).to raise_error ArgumentError
+        end
+
+      end
+
+      context 'when passing data as an array of filepaths' do
+        before do
+          fakefile = OpenStruct.new :read => file_data
+          allow(File).to receive(:open).with(file_path + '.jpg').and_return(fakefile)
+          expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post", {
+            'data[0]' => kind_of(Faraday::UploadIO),
+            :type => type.to_s
+          }).and_return('post')
+        end
+        
+        it 'should be able to pass data as an array of filepaths' do
+          r = client.send type, blog_name, :data => [file_path + ".jpg"]
+          expect(r).to eq('post')
+        end
+
+        it 'should be able to pass data as an array of uploadios' do
+          r = client.send type, blog_name, :data => [Faraday::UploadIO.new(StringIO.new, 'image/jpeg')]
+          expect(r).to eq('post')
+        end
+
+      end
+
+      context 'when passing data different ways' do
+
+        before do
+          fakefile = OpenStruct.new :read => file_data
+          allow(File).to receive(:open).with(file_path + '.jpg').and_return(fakefile)
+          expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post", {
+            'data' => kind_of(Faraday::UploadIO),
+            :type => type.to_s
+          }).and_return('post')
+        end
+
+        it 'should be able to pass data as a single filepath' do
+          r = client.send type, blog_name, :data => file_path + ".jpg"
+          expect(r).to eq('post')
+        end
+
+        it 'should be able to pass data as a single uploadio' do
+          r = client.send type, blog_name, :data => Faraday::UploadIO.new(StringIO.new, 'image/jpeg')
+          expect(r).to eq('post')
+        end
+
+      end
+
+      # Only photos have source
+      if type == :photo
+
+        context 'when passing source different ways' do
+
+          it 'should be able to be passed as a string' do
+            expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post", {
+              :source => source,
+              :type => type.to_s
+            })
+            client.send type, blog_name, :source => source
+          end
+
+          it 'should be able to be passed as an array' do
+            expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post", {
+              'source[0]' => source,
+              'source[1]' => source,
+              :type => type.to_s
+            })
+            client.send type, blog_name, :source => [source, source]
+          end
+
+          it 'should be able to be passed as an array on edit' do
+            expect(client).to receive(:post).once.with("v2/blog/#{blog_name}/post/edit", {
+              :id => post_id,
+              'source[0]' => source,
+              'source[1]' => source
+            })
+            client.edit blog_name, :id => post_id, :source => [source, source]
+          end
+
+        end
+
+      end
+
+      context 'when passing colliding options' do
+
+        it 'should get an error when passing data & source' do
+          expect(lambda {
+            client.send type, blog_name, :data => 'hi', :source => 'bye'
+          }).to raise_error ArgumentError
+        end
+
+      end
+
+    end
+
+  end
+
+end