bitlyr 0.9.0

data/test/integration/test_user.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class TestUser < Test::Unit::TestCase
+  context "with an access_token" do
+    setup do
+      consumer     = Bitlyr::Strategy::OAuth.new('consumer_token', 'consumer_secret')
+      access_token = consumer.get_access_token_from_token('token')
+      @user        = Bitlyr::User.new(access_token)
+    end
+
+    context 'referrers' do
+      setup do
+        stub_get(/https:\/\/api-ssl\.bit\.ly\/v3\/user\/referrers\?(access|oauth)_token=token/, 'user_referrers.json')
+        @referrers = @user.referrers
+      end
+
+      should 'return an array of arrays of referrers' do
+        assert_kind_of Array, @referrers
+        assert_kind_of Array, @referrers.first
+        assert_kind_of Bitlyr::Referrer, @referrers.first.first
+      end
+
+      should 'return data about the referrer' do
+        referrer = @referrers.first.first
+        assert_equal 'direct', referrer.referrer
+        assert_equal 1, referrer.clicks
+      end
+    end
+
+    context 'countries' do
+      setup do
+        stub_get(/https:\/\/api-ssl\.bit\.ly\/v3\/user\/countries\?(access|oauth)_token=token/, 'user_countries.json')
+        @countries = @user.countries
+      end
+
+      should 'return an array of arrays of countries' do
+        assert_kind_of Array, @countries
+        assert_kind_of Array, @countries.first
+        assert_kind_of Bitlyr::Country, @countries.first.first
+      end
+
+      should 'return data about the country' do
+        country = @countries.first.first
+        assert_equal "US", country.country
+        assert_equal 4, country.clicks
+      end
+    end
+
+    context 'clicks' do
+      setup do
+        stub_get(/https:\/\/api-ssl\.bit\.ly\/v3\/user\/clicks\?(access|oauth)_token=token/, 'user_clicks.json')
+        @clicks = @user.clicks
+      end
+
+      should 'return an array of days' do
+        assert_kind_of Array, @clicks
+        assert_kind_of Bitlyr::Day, @clicks.first
+      end
+
+      should 'return data about the day' do
+        day = @clicks.first
+        assert_equal 4, day.clicks
+      end
+
+      should 'get total clicks' do
+        assert_equal 29, @user.total_clicks
+      end
+    end
+
+    context 'total clicks' do
+      setup do
+        stub_get(/https:\/\/api-ssl\.bit\.ly\/v3\/user\/clicks\?(access|oauth)_token=token/, 'user_clicks.json')
+      end
+
+      should 'get total clicks' do
+        assert_equal 29, @user.total_clicks
+      end
+    end
+
+    context 'realtime links' do
+      setup do
+        stub_get(/https:\/\/api-ssl\.bit\.ly\/v3\/user\/realtime_links\?(access|oauth)_token=token/, 'user_realtime_links.json')
+        @realtime_links = @user.realtime_links
+      end
+
+      should 'get an array of realtime links' do
+        assert_kind_of Array, @realtime_links
+        assert_kind_of Bitlyr::RealtimeLink, @realtime_links.first
+      end
+
+      should 'get the data for the realtime links' do
+        assert_equal 15, @realtime_links.first.clicks
+        assert_equal "i7JWw0", @realtime_links.first.user_hash
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'fakeweb'
+require 'ruby-debug'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'bitlyr'
+
+FakeWeb.allow_net_connect = false
+
+def fixture_file(filename)
+  return '' if filename == ''
+  file_path = File.expand_path(File.dirname(__FILE__) + '/fixtures/' + filename)
+  File.read(file_path)
+end
+
+def stub_get(path, filename)
+  if filename.is_a?(Array)
+    response = filename.map { |f| { :body => fixture_file(f), :content_type => 'text/json' } }
+  else
+    response = { :body => fixture_file(filename), :content_type => 'text/json' }
+  end
+  FakeWeb.register_uri(:get, path, response)
+end
+
+def stub_post(path, filename)
+  response = { :body => fixture_file(filename), :content_type => 'text/json' }
+  FakeWeb.register_uri(:post, path, response)
+end
+
+def api_key_fixture
+  'test_key'
+end
+def login_fixture
+  'test_account'
+end
+def client_id_fixture
+  'client_id'
+end
+def client_secret_fixture
+  'client_secret'
+end
+def fixture_token
+  'token'
+end
+
+class Test::Unit::TestCase
+  def teardown
+    FakeWeb.clean_registry
+  end
+end

data/test/unit/core_ext/test_hash.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class TestHash < Test::Unit::TestCase
+  context "calling #to_params" do
+    setup do
+      @hash = { :one => 1, :two => 2 }
+    end
+    should "return a string of key=value&" do
+      assert_equal @hash.to_query, "one=1&two=2"
+    end
+  end
+
+  context "calling #stringify_keys!" do
+    setup do
+      @hash = { :one => 1, :two => 2 }
+    end
+    should "return a hash with string keys" do
+      assert_equal @hash.stringify_keys!.keys.map(&:class).uniq.size, 1
+      assert_equal @hash.stringify_keys!.keys.map(&:class).uniq.first, String
+    end
+    should "should alter the original hash" do
+      @hash.stringify_keys!
+      assert_equal @hash.keys.map(&:class).uniq.size, 1
+      assert_equal @hash.keys.map(&:class).uniq.first, String
+    end
+  end
+  context "calling #stringify_keys" do
+    setup do
+      @hash = { :one => 1, :two => 2 }
+    end
+    should "return a hash with string keys" do
+      assert_equal @hash.stringify_keys.keys.map(&:class).uniq.size, 1
+      assert_equal @hash.stringify_keys.keys.map(&:class).uniq.first, String
+    end
+    should "should return a new hash" do
+      @hash.stringify_keys
+      assert_equal @hash.keys.map(&:class).uniq.size, 1
+      assert_equal @hash.keys.map(&:class).uniq.first, Symbol
+    end
+  end
+  context "calling #symbolize_keys!" do
+    setup do
+      @hash = { 'one' => 1, 'two' => 2 }
+    end
+    should "return a hash with string keys" do
+      assert_equal @hash.symbolize_keys!.keys.map(&:class).uniq.size, 1
+      assert_equal @hash.symbolize_keys!.keys.map(&:class).uniq.first, Symbol
+    end
+    should "should alter the original hash" do
+      @hash.symbolize_keys!
+      assert_equal @hash.keys.map(&:class).uniq.size, 1
+      assert_equal @hash.keys.map(&:class).uniq.first, Symbol
+    end
+  end
+  context "calling #symbolize_keys" do
+    setup do
+      @hash = { 'one' => 1, 'two' => 2 }
+    end
+    should "return a hash with string keys" do
+      assert_equal @hash.symbolize_keys.keys.map(&:class).uniq.size, 1
+      assert_equal @hash.symbolize_keys.keys.map(&:class).uniq.first, Symbol
+    end
+    should "should alter the original hash" do
+      @hash.symbolize_keys
+      assert_equal @hash.keys.map(&:class).uniq.size, 1
+      assert_equal @hash.keys.map(&:class).uniq.first, String
+    end
+  end
+end

data/test/unit/core_ext/test_string.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class TestString < Test::Unit::TestCase
+  context "Ruby String" do
+    setup do
+      @string = "string"
+    end
+    context "calling to_params" do
+      should "return a string of key=value&" do
+        assert_equal @string.to_a, [ @string ]
+      end
+    end
+  end
+end

data/test/unit/strategy/test_access_token.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class TestAccessToken < Test::Unit::TestCase
+  context "with an id and secret" do
+    setup do
+      oauth     = Bitlyr::Strategy::OAuth.new('id', 'secret')
+      @strategy = oauth.get_access_token_from_token('token')
+    end
+    should 'get access token with access token' do
+      access_token = @strategy.send(:access_token)
+      assert_kind_of OAuth2::AccessToken, access_token
+    end
+  end
+end

data/test/unit/strategy/test_api_key.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class TestApiKey < Test::Unit::TestCase
+  context "creating a new ApiKey Strategy" do
+    should "initialize with login and api key" do
+      assert_nothing_raised do
+        Bitlyr::Strategy::ApiKey.new(login_fixture, api_key_fixture)
+      end
+    end
+  end
+end

data/test/unit/strategy/test_base.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class TestBase < Test::Unit::TestCase
+  context "a request" do
+    context "when successful" do
+      setup do
+        Bitlyr::Response.stubs(:new => stub('response', :success? => true, :body => {}))
+        @strategy = Bitlyr::Strategy::Base.new
+      end
+      should "should proxy the request to run_request" do
+        @strategy.expects(:run_request).once
+        @strategy.request
+      end
+      should "should pass the args to run request" do
+        @strategy.stubs(:run_request).with("these", "args")
+        @strategy.request("these", "args")
+      end
+      should "return the body of the bitlyr response" do
+        @strategy.stubs(:run_request => true)
+        assert_equal @strategy.request, {}
+      end
+    end
+    context "when unsuccessful" do
+      should "raise a Bitlyr Error" do
+        response = stub('response', :success? => false, :reason => "reason", :status => 500)
+        Bitlyr::Response.stubs(:new => response)
+        strategy = Bitlyr::Strategy::Base.new
+        strategy.stubs(:run_request => true)
+        assert_raise BitlyrError do
+          strategy.request
+        end
+      end
+    end
+  end
+  context "run_request" do
+    should "raise a Runtime Error" do
+      strategy = Bitlyr::Strategy::Base.new
+      assert_raise RuntimeError do
+        strategy.send :run_request
+      end
+    end
+  end
+  context "validating a login and apiKey" do
+    context "with valid login and apiKey" do
+      setup do
+        Bitlyr::Response.stubs(:new => stub('response', :success? => true, :body => {'valid' => 1}))
+        @strategy = Bitlyr::Strategy::Base.new
+        @strategy.expects(:run_request).once
+      end
+      should "return true when calling validate" do
+        assert @strategy.validate(login_fixture, api_key_fixture)
+      end
+      should "return true when calling valid?" do
+        assert @strategy.valid?(login_fixture, api_key_fixture)
+      end
+    end
+    context "with an invalid login and apiKey" do
+      setup do
+        Bitlyr::Response.stubs(:new => stub('response', :success? => true, :body => {'valid' => 0}))
+        @strategy = Bitlyr::Strategy::Base.new
+        @strategy.expects(:run_request).once
+      end
+      should "return false when calling validate" do
+        assert !@strategy.validate("bogus", "info")
+      end
+      should "return false when valling valid?" do
+        assert !@strategy.valid?("bogus", "info")
+      end
+    end
+  end
+end

data/test/unit/strategy/test_oauth.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class TestOAuthStrategy < Test::Unit::TestCase
+  context "with an id and secret" do
+    setup do
+      @client_id     = 'id'
+      @client_secret = 'secret'
+      @strategy      = Bitlyr::Strategy::OAuth.new(@client_id, @client_secret)
+    end
+    should 'create the oauth client' do
+      assert_kind_of OAuth2::Client, @strategy.send(:client)
+    end
+    should 'save the strategy details on the client' do
+      assert_equal @client_id,     @strategy.send(:client).id
+      assert_equal @client_secret, @strategy.send(:client).secret
+    end
+    should 'get the oauth authorize url' do
+      assert_match %r{https://api-ssl\.bit\.ly/oauth/authorize\?.*client_id=#{@client_id}.*}, @strategy.authorize_url('http://test.local')
+    end
+    should 'get access token with access token' do
+      access_token = @strategy.get_access_token_from_token('hello')
+      assert_kind_of Bitlyr::Strategy::AccessToken, access_token
+      assert_equal @strategy.send(:client), access_token.client
+    end
+    should 'set access token with access token' do
+      @strategy.set_access_token_from_token!('hello')
+      access_token = @strategy.send(:access_token)
+      assert_kind_of Bitlyr::Strategy::AccessToken, access_token
+      assert_equal @strategy.send(:client), access_token.client
+    end
+  end
+end

data/test/unit/test_bitly.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class TestBitlyr < Test::Unit::TestCase
+  context "bitlyr module" do
+    context "with a login and api key" do
+      should "create a new bitlyr client" do
+        bitlyr = Bitlyr.new(:login => "login", :api_key => "api key")
+        assert bitlyr.is_a?(Bitlyr::Client)
+      end
+      should "create have a ApiKey Strategy" do
+        strategy = Bitlyr.new(:login => "login", :api_key => "api key").send(:strategy)
+        assert strategy.is_a?(Bitlyr::Strategy::ApiKey)
+      end
+    end
+    context "with a client id and client secret" do
+      should "create a new bitlyr client" do
+        bitlyr = Bitlyr.new(:client_id => "client id", :client_secret => "client secret")
+        assert bitlyr.is_a?(Bitlyr::Client)
+      end
+      should "create have a OAuth Strategy" do
+        strategy = Bitlyr.new(:client_id => "client id", :client_secret => "client secret").send(:strategy)
+        assert strategy.is_a?(Bitlyr::Strategy::OAuth)
+      end
+    end
+    context "with a client id, client secret and token" do
+      should "create a new bitlyr client" do
+        bitlyr = Bitlyr.new(:client_id => "client id", :client_secret => "client secret", :token => "token")
+        assert bitlyr.is_a?(Bitlyr::Client)
+      end
+      should "create have a OAuth Strategy" do
+        strategy = Bitlyr.new(:client_id => "client id", :client_secret => "client secret", :token => "token").send(:strategy)
+        assert strategy.is_a?(Bitlyr::Strategy::OAuth)
+      end
+    end
+    context "with bad information" do
+      should "raise an error" do
+        assert_raise RuntimeError do
+          Bitlyr.new({})
+        end
+      end
+    end
+  end
+end

data/test/unit/test_client.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class TestClient < Test::Unit::TestCase
+  context "creating a new client" do
+    should "initialize with ApiKey strategy" do
+      assert_nothing_raised do
+        Bitlyr::Client.new Bitlyr::Strategy::ApiKey.new(login_fixture, api_key_fixture)
+      end
+    end
+    should "initialize with OAuth strategy" do
+      assert_nothing_raised do
+        Bitlyr::Client.new Bitlyr::Strategy::OAuth.new(client_id_fixture, client_secret_fixture)
+      end
+    end
+    should "raise an exception when bad arguments are used" do
+      assert_raise ArgumentError do
+        Bitlyr::Client.new("Something Else")
+      end
+    end
+  end
+end

data/test/unit/test_country.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class TestCountry < Test::Unit::TestCase
+  context "a country" do
+    setup do
+      @country = Bitlyr::Country.new
+    end
+
+    [:clicks, :country].each do |method|
+      should "respond to #{method}" do
+        assert_respond_to @country, method
+      end
+
+      should "set #{method} when initializing" do
+        country = Bitlyr::Country.new(method.to_s => 'test')
+        assert_equal 'test', country.send(method)
+      end
+    end
+  end
+end

data/test/unit/test_day.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class TestDay < Test::Unit::TestCase
+  context "a day" do
+    setup do
+      @day = Bitlyr::Day.new
+    end
+    [:clicks, :day_start].each do |method|
+      should "respond to #{method}" do
+        assert_respond_to @day, method
+      end
+    end
+    should "set clicks when initializing" do
+      day = Bitlyr::Day.new('clicks' => 12)
+      assert_equal 12, day.clicks
+    end
+    should "set day to a time object when initialising" do
+      day = Bitlyr::Day.new('day_start' => 1290488400)
+      assert_equal Time.parse('2010/11/23'), day.day_start
+    end
+  end
+end

data/test/unit/test_error.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class TestBitlyrError < Test::Unit::TestCase
+  should "create a new bitlyr client" do
+    res = mock(:status => 'code', :reason => 'message')
+    error = BitlyrError.new(res)
+    assert_equal "message - 'code'", error.message
+    assert_equal "message - 'code'", error.msg
+    assert_equal "code", error.code
+  end
+end

data/test/unit/test_missing.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class TestMissingUrl < Test::Unit::TestCase
+  context "a url" do
+    setup do
+      @url = Bitlyr::MissingUrl.new
+    end
+    [:short_url, :user_hash, :long_url, :error].each do |method|
+      should "respond to #{method}" do
+        assert_respond_to @url, method
+      end
+    end
+  end
+  context "#new" do
+    setup do
+      @url = Bitlyr::MissingUrl.new({ 'short_url' => 'short url',
+                                     'hash'      => 'hash',
+                                     'long_url'  => 'long url',
+                                     'error'     => 'error' })
+    end
+    should "return the short url" do
+      assert_equal 'short url', @url.short_url
+    end
+    should "return the user hash" do
+      assert_equal 'hash', @url.user_hash
+    end
+    should "return the long url" do
+      assert_equal 'long url', @url.long_url
+    end
+    should "return the error" do
+      assert_equal 'error', @url.error
+    end
+  end
+end

data/test/unit/test_realtime_link.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class TestRealtimeLink < Test::Unit::TestCase
+  context "a realtime link" do
+    setup do
+      @realtime_link = Bitlyr::RealtimeLink.new
+    end
+    [:clicks, :user_hash].each do |method|
+      should "respond to #{method}" do
+        assert_respond_to @realtime_link, method
+      end
+    end
+    should "set clicks when initializing" do
+      realtime_link = Bitlyr::RealtimeLink.new('clicks' => 12)
+      assert_equal 12, realtime_link.clicks
+    end
+    should "set user_hash when initializing" do
+      realtime_link = Bitlyr::RealtimeLink.new('user_hash' => 'sdfidn')
+      assert_equal 'sdfidn', realtime_link.user_hash
+    end
+    should 'create a url when supplied with a client' do
+      realtime_link = Bitlyr::RealtimeLink.new('user_hash' => 'sdfidn', 'clicks' => 12)
+      client = Bitlyr::Client.new(Bitlyr::Strategy::ApiKey.new(login_fixture, api_key_fixture))
+      url = realtime_link.create_url(client)
+      assert_kind_of Bitlyr::Url, url
+      assert_equal 12, url.user_clicks
+      assert_equal 'sdfidn', url.user_hash
+    end
+  end
+end

data/test/unit/test_referrer.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class TestReferrer < Test::Unit::TestCase
+  context "a referrer" do
+    setup do
+      @referrer = Bitlyr::Referrer.new({})
+    end
+
+    [:clicks, :referrer, :referrer_app, :url].each do |method|
+      should "respond to #{method}" do
+        assert_respond_to @referrer, method
+      end
+
+      should "set #{method} when initializing" do
+        referrer = Bitlyr::Referrer.new(method.to_s => 'test')
+        assert_equal 'test', referrer.send(method)
+      end
+    end
+  end
+end

data/test/unit/test_response.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+class TestResponse < Test::Unit::TestCase
+  context "with a unsupported response" do
+    should "raise an error" do
+      assert_raises RuntimeError, "Unsupported Response type: Object" do
+        Bitlyr::Response.new(Object.new).success?
+      end
+    end
+  end
+  context "with an oauth response" do
+    setup do
+      OAuth2::Response.stubs(:=== => true)
+    end
+    should "return true" do
+      response = Bitlyr::Response.new(stub('oauth', :parsed => {'status_code' => 200}))
+      assert_equal true, response.success?
+    end
+    should "return false" do
+      response = Bitlyr::Response.new(stub('oauth', :parsed => {'status_code' => 'not 200'}))
+      assert_equal false, response.success?
+    end
+    should "return the status code" do
+      response = Bitlyr::Response.new(stub('oauth', :parsed => {'status_code' => 'some status code'}))
+      assert_equal 'some status code', response.status,
+    end
+    should "return the response body" do
+      response = Bitlyr::Response.new(stub('oauth', :parsed => { 'data' => {} } ))
+      assert_equal Hash.new, response.body
+    end
+    should "return the response body" do
+      response = Bitlyr::Response.new(stub('oauth', :parsed => {'data' => nil}))
+      assert_equal nil, response.body
+    end
+    should "return the status text reason" do
+      response = Bitlyr::Response.new(stub('oauth', :parsed => {'status_txt' => "OK"}))
+      assert_equal "OK", response.reason
+    end
+    should "return the status text reason" do
+      response = Bitlyr::Response.new(stub('oauth', :parsed => {'status_txt' => "RATE_LIMIT_EXCEEDED"}))
+      assert_equal "Rate Limit Exceeded", response.reason
+    end
+    should "return the status text reason" do
+      response = Bitlyr::Response.new(stub('oauth', :parsed => {'status_txt' => "INVALID_ANYTHING"}))
+      assert_equal "Invalid Anything", response.reason
+    end
+  end
+
+  context "with a HTTParty response" do
+    setup do
+      HTTParty::Response.stubs(:=== => true)
+    end
+    should "return true" do
+      response = Bitlyr::Response.new(stub(:parsed_response => { 'status_code' => 200 } ))
+      assert_equal true, response.success?
+    end
+    should "return false" do
+      response = Bitlyr::Response.new(stub(:parsed_response => { 'status_code' => 'not 200' }))
+      assert_equal false, response.success?
+    end
+    should "return the status code" do
+      response = Bitlyr::Response.new(stub(:parsed_response => { 'status_code' => 'some status code' }))
+      assert_equal 'some status code', response.status,
+    end
+    should "return the response body" do
+      response = Bitlyr::Response.new(stub(:parsed_response => { 'data' => {} } ))
+      assert_equal Hash.new, response.body
+    end
+    should "return the response body" do
+      response = Bitlyr::Response.new(stub(:parsed_response => { 'data' => nil }))
+      assert_equal nil, response.body
+    end
+    should "return the status text reason" do
+      response = Bitlyr::Response.new(stub(:parsed_response => { 'status_txt' => "OK" }))
+      assert_equal "OK", response.reason
+    end
+    should "return the status text reason" do
+      response = Bitlyr::Response.new(stub(:parsed_response => { 'status_txt' => "RATE_LIMIT_EXCEEDED" }))
+      assert_equal "Rate Limit Exceeded", response.reason
+    end
+    should "return the status text reason" do
+      response = Bitlyr::Response.new(stub(:parsed_response => { 'status_txt' => "INVALID_ANYTHING" }))
+      assert_equal "Invalid Anything", response.reason
+    end
+  end
+end