whatser 0.2.0

data/test/helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'whatser'
+
+class Test::Unit::TestCase
+end
+
+module Whatser
+  module Http
+    def request(verb, path, options={})
+      Whatser::Response.new('')
+    end
+  end
+end

data/test/test_activity_feed.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+class TestActivityFeed < Test::Unit::TestCase
+  def setup
+    @client = Whatser::Client.new(:oauth_token => '1234')
+    @user_id = 1
+  end
+  
+  def test_my_feed
+    assert @client.feeds.mine( :page => 1, :per_page => 10 ).is_a?(Whatser::Response)
+  end
+  
+  def test_user_feed
+    assert @client.feeds.user( @user_id, :page => 1, :per_page => 10 ).is_a?(Whatser::Response)
+  end
+  
+  def test_global_feed
+    assert @client.feeds.global( :page => 1, :per_page => 10 ).is_a?(Whatser::Response)
+  end  
+end

data/test/test_check_in.rb

@@ -0,0 +1,28 @@
+require 'helper'
+
+class TestPoi < Test::Unit::TestCase
+  def setup
+    @client = Whatser::Client.new
+    @poi_id = 1
+    @check_in = Whatser::CheckIn.new(:poi_id => @poi_id)
+  end
+  
+  def test_list
+    assert @client.check_ins.list(:page => @poi_id).is_a?(Whatser::Response)
+  end
+  
+  def test_create
+    assert @client.check_ins.create(@poi_id, :check_in_at => Time.now).is_a?(Whatser::Response)
+  end  
+  
+  def test_save
+    assert @check_in.save.is_a?(Whatser::Response)
+  end
+    
+  def test_to_params
+    params = [:locate,:lat,:lng,:gowalla,:foursquare,:check_in_at,:check_out_at]
+    params.each do |p|
+      assert @check_in.to_params.keys.include?(p)
+    end
+  end  
+end

data/test/test_city.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+class TestCity < Test::Unit::TestCase
+  def setup
+    @client = Whatser::Client.new(:oauth_token => '1234')
+    @user_id = 1
+  end
+  
+  def test_my_cities
+    assert @client.cities.mine( :page => 1, :per_page => 10 ).is_a?(Whatser::Response)
+  end
+  
+  def test_user_cities
+    assert @client.cities.user( @user_id, :page => 1, :per_page => 10 ).is_a?(Whatser::Response)
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,84 @@
+require 'helper'
+
+class TestClient < Test::Unit::TestCase
+  def test_attr_accessor
+    client = Whatser::Client.new
+    Whatser::Configuration::VALID_OPTIONS_KEYS.each do |a|
+      assert client.respond_to?(a)
+    end
+  end
+  
+  def test_cattr_accessor
+    Whatser::Configuration::VALID_OPTIONS_KEYS.each do |a|
+      assert Whatser::Client.respond_to?(a)
+    end
+  end  
+  
+  def test_initialize_with_options
+    params = {:api_key => '123', 
+              :api_secret => 'abc', 
+              :oauth_token => 'xyz',
+              :api_uri => 'www.example.com',
+              :username => 'test@example.com', 
+              :password => 'test'}
+              
+    client = Whatser::Client.new( params )
+    assert_equal params[:api_key], client.api_key
+    assert_equal params[:api_secret], client.api_secret
+    assert_equal params[:username], client.username
+    assert_equal params[:password], client.password
+  end
+  
+  def test_initialize_with_configure_defaults
+    Whatser::Client.configure do |config|
+      config.api_key = 'key'
+      config.api_secret = 'secret'
+      config.oauth_token = '123abc'
+    end
+    client = Whatser::Client.new  
+    assert_equal 'key', client.api_key
+    assert_equal 'secret', client.api_secret
+    assert_equal '123abc', client.oauth_token
+  end
+  
+  def test_resources
+    client = Whatser::Client.new
+    assert_equal Whatser::CheckIn, client.check_ins
+    assert_equal Whatser::Collection, client.collections
+    assert_equal Whatser::DataSource, client.data_sources
+    assert_equal Whatser::Detail, client.details
+    assert_equal Whatser::Media, client.media
+    assert_equal Whatser::Poi, client.spots
+    assert_equal Whatser::Subscription, client.subscriptions
+    assert_equal Whatser::Tag, client.tags
+    assert_equal Whatser::User, client.users    
+    assert_equal Whatser::Follow, client.follows
+    assert_equal Whatser::Facebook, client.facebook
+    assert_equal Whatser::Foursquare, client.foursquare
+    assert_equal Whatser::Gowalla, client.gowalla
+    assert_equal Whatser::Twitter, client.twitter
+    
+    assert_equal client, client.check_ins.client
+    assert_equal client, client.collections.client
+    assert_equal client, client.data_sources.client
+    assert_equal client, client.details.client
+    assert_equal client, client.media.client
+    assert_equal client, client.spots.client
+    assert_equal client, client.subscriptions.client
+    assert_equal client, client.tags.client
+    assert_equal client, client.users.client
+    assert_equal client, client.follows.client
+    assert_equal client, client.facebook.client
+    assert_equal client, client.foursquare.client
+    assert_equal client, client.gowalla.client
+    assert_equal client, client.twitter.client
+  end
+  
+  def test_authorized
+    client = Whatser::Client.new
+    assert_equal false, client.authorized?
+    
+    client.oauth_token = 'test'
+    assert_equal true, client.authorized?
+  end
+end

data/test/test_collection.rb

@@ -0,0 +1,28 @@
+require 'helper'
+
+class TestCollection < Test::Unit::TestCase
+  def setup
+    @data = [1,2,3]
+  end
+  
+  def test_initialize
+    collection = Whatser::Collection.new(@data)
+    assert_equal @data, collection.data
+  end
+  
+  def test_each_enumerable
+    iterated = []
+    collection = Whatser::Collection.new(@data)
+    collection.each do |c|
+      iterated << c
+    end
+    assert_equal @data, iterated
+  end
+  
+  def test_size
+    collection = Whatser::Collection.new
+    assert_equal 0, collection.size
+    collection.data = @data
+    assert_equal @data.size, collection.size
+  end
+end

data/test/test_configuration.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+class TestConfiguration < Test::Unit::TestCase
+  def reset_defaults
+    Whatser::Client.configure do |config|
+      config.api_key = nil
+      config.api_secret = nil
+      config.oauth_token = nil
+    end    
+  end
+  
+  def test_valid_options_keys
+    expected = [:api_key,:api_secret,:username,:password,:oauth_token,:api_uri,:redirect_uri]
+    assert_equal expected, Whatser::Configuration::VALID_OPTIONS_KEYS
+  end
+  
+  def test_defaults_on_inclusion
+    reset_defaults
+    client = Whatser::Client.new
+    assert_equal nil, client.api_key
+    assert_equal nil, client.api_secret
+    assert_equal nil, client.oauth_token
+    assert_equal nil, client.redirect_uri
+    assert_equal Whatser::Configuration::DEFAULT_API_URI, client.api_uri
+  end
+end

data/test/test_data_source.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+class TestDataSource < Test::Unit::TestCase
+  def setup
+    @client = Whatser::Client.new(:oauth_token => '1234')
+  end
+  
+  def test_list
+    assert @client.data_sources.list(:page => 1).is_a?(Whatser::Response)
+  end
+  
+  def test_for_users_with_id
+    assert @client.data_sources.for_users(1, :page => 1).is_a?(Whatser::Response)
+  end  
+
+  def test_for_users_with_string
+    assert @client.data_sources.for_users('1,2,3', :page => 1).is_a?(Whatser::Response)
+  end  
+
+  def test_for_users_with_array
+    assert @client.data_sources.for_users([1,2,3], :page => 1).is_a?(Whatser::Response)
+  end
+    
+  def test_subscription_url
+    datasource = @client.data_sources.new(:id => '1')
+    expected = "#{@client.api_uri}/payments/data_sources/1/orders/new?oauth_token=1234"
+    assert_equal expected, datasource.subscription_url
+  end
+  
+  def test_subscription_url_with_params  
+    datasource = @client.data_sources.new(:id => '1')
+    expected = "#{@client.api_uri}/payments/data_sources/1/orders/new?oauth_token=1234&test=2&extra=1"
+    assert_equal expected, datasource.subscription_url(:extra => 1, :test => 2)
+  end
+end

data/test/test_detail.rb

@@ -0,0 +1,38 @@
+require 'helper'
+
+class TestDetail < Test::Unit::TestCase
+  def setup
+    @client = Whatser::Client.new
+    @poi_id = 1
+    @params = {:rating => 'four stars', :hours => '9-5'}
+    @detail = Whatser::Detail.new(:poi_id => @poi_id, :data => @params)
+  end
+  
+  def test_list
+    assert @client.reviews.list(@poi_id, :page => 1).is_a?(Whatser::Response)
+  end
+  
+  def test_create
+    assert @client.reviews.create(@poi_id, :data => @params).is_a?(Whatser::Response)
+  end
+  
+  def test_delete
+    assert @client.reviews.delete(@poi_id, :data => @params).is_a?(Whatser::Response)
+  end  
+  
+  def test_save
+    assert @detail.save.is_a?(Whatser::Response)
+  end
+  
+  def test_update
+    @detail.id = 1
+    assert @detail.save.is_a?(Whatser::Response)
+  end  
+    
+  def test_to_params
+    params = [:data]
+    params.each do |p|
+      assert @detail.to_params.keys.include?(p)
+    end
+  end  
+end

data/test/test_facebook.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestFacebook < Test::Unit::TestCase
+  def test_key
+    assert_equal 'facebook', Whatser::Facebook.new.key
+  end
+end

data/test/test_follow.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+class TestFollow < Test::Unit::TestCase
+  def setup
+    @client = Whatser::Client.new
+    @user_id = 1
+    @follow = Whatser::Follow.new(:id => @user_id)
+  end
+ 
+  def test_list
+    assert @client.follows.list(:page => 1).is_a?(Whatser::Response)
+  end
+  
+  def test_suggested
+    assert @client.follows.suggested(:page => 1).is_a?(Whatser::Response)
+  end  
+
+  def test_create
+    assert @client.follows.create(@user_id).is_a?(Whatser::Response)
+  end
+
+  def test_delete
+    assert @client.follows.delete(@user_id).is_a?(Whatser::Response)
+  end
+
+  def test_ignore
+    assert @client.follows.ignore(@user_id).is_a?(Whatser::Response)
+  end  
+
+  def test_save
+    assert @follow.save.is_a?(Whatser::Response)
+  end
+end

data/test/test_foursquare.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestFoursquare < Test::Unit::TestCase
+  def test_key
+    assert_equal 'foursquare', Whatser::Foursquare.new.key
+  end
+end

data/test/test_gowalla.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestGowalla < Test::Unit::TestCase
+  def test_key
+    assert_equal 'gowalla', Whatser::Gowalla.new.key
+  end
+end

data/test/test_hondius.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class TestWhatser < Test::Unit::TestCase
+  def test_client
+    assert Whatser.client.is_a?( Whatser::Client )
+  end
+  
+  def test_client_cached
+    client = Whatser.client
+    assert_equal client.object_id, Whatser.client.object_id
+  end
+end

data/test/test_http.rb

@@ -0,0 +1,40 @@
+require 'helper'
+
+class TestHttp < Test::Unit::TestCase  
+  def setup
+    @client = Whatser.client
+  end
+  
+  def test_request_options_default
+    @client.oauth_token = '123'
+    expected = {:query => {:oauth_token => '123'}, :body => nil}
+    assert_equal expected, @client.send(:request_options)
+  end
+  
+  def test_request_options_with_query
+    @client.oauth_token = '123'
+    expected = {:query => {:oauth_token => '123', :extra => 1}, :body => nil}
+    assert_equal expected, @client.send(:request_options, {:query => {:extra => 1} })
+  end  
+  
+  def test_request_options_with_body
+    @client.oauth_token = '123'
+    expected = {:query => {:oauth_token => '123'}, :body => {:extra => 1}}
+    assert_equal expected, @client.send(:request_options, {:body => {:extra => 1} })
+  end  
+  
+  def test_base_uri_on_included
+    assert_equal @client.api_uri, Whatser::Http.base_uri
+  end
+  
+  def test_request
+    response = @client.request(:get, '/', {})
+    assert response.is_a?(Whatser::Response)
+  end
+  
+  def test_compose_url
+    path = '/api/endpoint'
+    uri = @client.api_uri
+    assert_equal "#{uri}#{path}", @client.send(:compose_url, path)
+  end
+end

data/test/test_oauth.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+class TestOauth < Test::Unit::TestCase
+  def test_oauth_client
+    params = {:api_key => '123', :api_secret => '123', :api_uri => 'http://example.com'}
+    client = Whatser::Client.new(params)
+    oauth = client.oauth_client
+    assert oauth.is_a?(OAuth2::Client)
+    assert_equal params[:api_key], oauth.id
+    assert_equal params[:api_secret], oauth.secret
+    assert_equal params[:api_uri], oauth.site
+  end
+  
+  def test_oauth_authorize_url
+    base = 'http://example.com/oauth/authorize'
+    client = Whatser::Client.new(:api_uri => base, :api_key => '123')
+    assert_equal "#{base}?client_id=123&type=web_server", client.oauth_authorize_url
+    assert_equal "#{base}?client_id=123&type=web_server&redirect_uri=http%3A%2F%2Fexample.com%2Foauth%2Fauthorize", client.oauth_authorize_url(:redirect_uri => base)
+  end
+  
+  def test_hash_to_query
+    client = Whatser::Client.new
+    assert_equal ["first=1","second=2"].sort, client.send(:hash_to_query, {:first => 1, :second => 2}).split('&').sort
+    assert_equal "", client.send(:hash_to_query, {} ) 
+  end
+  
+  def test_password_grant_params
+    params = {:api_key => '123', :api_secret => '123', :api_uri => 'http://example.com'}
+    client = Whatser::Client.new(params)
+    expected = {'grant_type' => 'password', 
+      'client_id' => '123',
+      'client_secret' => '123',
+      'username' => 'mail',
+      'password' => 'pw'}
+    assert_equal expected, client.send(:password_grant_params, 'mail', 'pw') 
+  end
+end

data/test/test_poi.rb

@@ -0,0 +1,75 @@
+require 'helper'
+
+class TestPoi < Test::Unit::TestCase
+  def setup
+    @client = Whatser::Client.new
+    @poi = Whatser::Poi.new
+  end
+  
+  def test_to_params
+    poi = Whatser::Poi.new
+    params = [:name,:lat,:lng,:street,:district,:region,:city,:postal_code,:country]
+    params.each do |p|
+      assert poi.to_params.keys.include?(p)
+    end
+  end
+  
+  def test_suggested
+    assert @client.spots.suggested(:opt => 'test').is_a?(Whatser::Response)
+  end
+  
+  def test_search
+    assert @client.spots.search(:opt => 'test').is_a?(Whatser::Response)
+  end
+  
+  def test_find
+    assert @client.spots.find(1, :opt => 'test').is_a?(Whatser::Response)
+  end
+  
+  def test_create
+    assert @client.spots.create(:name => 'test', :lat => 45, :lng => 45).is_a?(Whatser::Response)
+  end
+  
+  def test_delete
+    assert @client.spots.delete(1).is_a?(Whatser::Response)
+  end  
+  
+  def test_save
+    assert @poi.save.is_a?(Whatser::Response)
+  end
+  
+  def test_save_and_update
+    @poi.id = 1
+    assert @poi.save.is_a?(Whatser::Response)
+  end
+  
+  def test_from_hash_to_model
+    hash = {'id' => 1, 'name' => 'test', 'lat' => 1, 'lng' => 1, 'street' => 'test', 
+            'district' => 'test', 'region' => 'test', 'city' => 'test', 'postal_code' => '1', 'country' => 'test'}
+    poi = Whatser::Poi.from_hash_to_model(hash)
+    assert poi.is_a?(Whatser::Poi)
+    
+    assert_equal hash['id'], poi.id
+    assert_equal hash['name'], poi.name
+    assert_equal hash['lat'], poi.lat
+    assert_equal hash['lng'], poi.lng
+    assert_equal hash['street'], poi.street
+    assert_equal hash['district'], poi.district
+    assert_equal hash['region'], poi.region
+    assert_equal hash['city'], poi.city
+    assert_equal hash['postal_code'], poi.postal_code
+    assert_equal hash['country'], poi.country
+  end
+  
+  def foursquare_connected
+    assert_equal false, @poi.foursquare_connected?
+    @poi.foursquare_id = 1
+    assert_equal true, @poi.foursquare_connected?
+  end
+  
+  def gowalla_connected
+    assert_equal false, @poi.foursquare_connected?
+    @poi.foursquare_id = 1
+    assert_equal true, @poi.foursquare_connected?
+  end  
+end

data/test/test_resource.rb

@@ -0,0 +1,73 @@
+require 'helper'
+
+class TestResource < Test::Unit::TestCase
+  def test_client
+    client = Whatser::Client.new
+    Whatser::Resource.instance_variable_set('@client',client)
+    assert_equal client, Whatser::Resource.client
+  end
+  
+  def test_set_client
+    client = Whatser::Client.new
+    res = Whatser::Resource.set(client)
+    assert_equal res.client, client
+  end
+  
+  def test_convert_data_to_model_with_blank
+    res = Whatser::Resource
+    assert_nil res.convert_data_to_model(nil)
+    assert_equal [], res.convert_data_to_model([])
+  end
+  
+  def test_convert_data_to_model_with_hash
+    res = Whatser::Resource
+    mod = res.convert_data_to_model(:test => '1', :testing => '1')
+    assert mod.is_a?(Whatser::Resource)
+  end
+  
+  def test_convert_data_to_model_with_array
+    res = Whatser::Resource
+    arr = res.convert_data_to_model([{:test => '1', :testing => '1'},{:test => '2', :testing => '1'}])
+    arr.each do |mod|
+      assert mod.is_a?(Whatser::Resource)
+    end
+  end  
+  
+  def test_api_request
+    Whatser::Resource.set( Whatser.client )
+    resource = Whatser::Resource
+    response = resource.api_request(:get, '/path', {})
+    assert response.is_a?(Whatser::Response)
+  end
+  
+  def test_instance_api_request
+    Whatser::Resource.set( Whatser.client )
+    resource = Whatser::Resource.new
+    response = resource.api_request(:get, '/path', {})
+    assert response.is_a?(Whatser::Response)
+  end
+  
+  def test_from_hash_to_model
+    hash = {:test => '1', :testing => '1'}
+    mod = Whatser::Resource.from_hash_to_model(hash)
+    assert mod.is_a?(Whatser::Resource)
+  end
+  
+  def test_from_hash_to_model_with_root
+    hash = {:root => {:test => '1', :testing => '1'}}
+    mod = Whatser::Resource.from_hash_to_model(hash)
+    assert mod.is_a?(Whatser::Resource)
+  end  
+  
+  def test_from_hash_to_model_with_option
+    hash = {:id => '1', :name => 'Test'}
+    option = Whatser::Poi
+    mod = Whatser::Resource.from_hash_to_model(hash, option)
+    assert mod.is_a?(Whatser::Poi)
+  end  
+  
+  def test_from_hash_to_model_empty
+    mod = Whatser::Resource.from_hash_to_model(nil)
+    assert mod.is_a?(Whatser::Resource)
+  end  
+end

data/test/test_response.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+class TestResponse < Test::Unit::TestCase
+  def test_initialize
+    res = Whatser::Response.new({})
+    assert_equal nil, res.data
+    res = Whatser::Response.new( {'data' => []} )
+    assert_equal [], res.data
+  end
+  
+  def test_load_from_hash
+    params = {'data'=>'test1','http_status'=>'test2','version'=>'test3','scope'=>'test4','page'=>'test5','per_page'=>'test6','more'=>'test7','error'=>'test8','error_description'=>'test9','error_uri'=>'test0'}
+    res = Whatser::Response.new({})
+    res.load_from_hash(params)
+    assert_equal params['data'], res.data
+    assert_equal params['http_status'], res.http_status
+    assert_equal params['version'], res.version
+    assert_equal params['scope'], res.scope
+    assert_equal params['page'], res.page
+    assert_equal params['per_page'], res.per_page
+    assert_equal params['more'], res.more
+    assert_equal params['error'], res.error
+    assert_equal params['error_description'], res.error_description
+    assert_equal params['error_uri'], res.error_uri
+  end
+  
+  def test_data_enum
+    res = Whatser::Response.new({})
+    assert_equal [], res.data_enum
+    res.data = "test"
+    assert_equal ["test"], res.data_enum
+    res.data = [1,2,3]
+    assert_equal [1,2,3], res.data_enum
+  end
+  
+  def test_each
+    res = Whatser::Response.new({})
+    res.data = [1,2,3]
+    assert res.respond_to?(:each)
+    res.each_with_index do |e,idx|
+      assert_equal res.data[idx], e
+    end
+  end
+end