gs_graph 2.6.5

data/spec/gs_graph/broad_targeting_category_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe GSGraph::BroadTargetingCategory, '.new' do
+  it 'should setup all supported attributes' do
+    attributes = {
+      :id => 6002714401172,
+      :name => "Baby Boomers",
+      :parent_category => "Family Status"
+    }
+
+    btc = GSGraph::BroadTargetingCategory.new(attributes.delete(:id), attributes)
+    btc.identifier.should == 6002714401172
+    btc.name.should == "Baby Boomers"
+    btc.parent_category.should == "Family Status"
+  end
+end
+

data/spec/gs_graph/checkin_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe GSGraph::Checkin, '.new' do
+  it 'should accept GSGraph::Place as place' do
+    checkin = GSGraph::Checkin.new(12345, :place => GSGraph::Place.new(123456))
+    checkin.place.should == GSGraph::Place.new(123456)
+  end
+
+  it 'should accept String/Integer as place' do
+    checkin1 = GSGraph::Checkin.new(12345, :place => 123456)
+    checkin2 = GSGraph::Checkin.new(12345, :place => '123456')
+    checkin1.place.should == GSGraph::Place.new(123456)
+    checkin2.place.should == GSGraph::Place.new('123456')
+  end
+end
+
+describe GSGraph::Checkin, '.search' do
+  context 'when no access_token given' do
+    it 'should raise GSGraph::Unauthorized' do
+      mock_graph :get, 'search', 'checkins/search_public', :params => {
+        :type => 'checkin'
+      }, :status => [401, 'Unauthorized'] do
+        lambda do
+          GSGraph::Checkin.search
+        end.should raise_exception(GSGraph::Unauthorized)
+      end
+    end
+  end
+
+  context 'when access_token is given' do
+    it 'should return checkins as GSGraph::Checkin' do
+      mock_graph :get, 'search', 'checkins/search_private', :access_token => 'access_token', :params => {
+        :type => 'checkin'
+      } do
+        checkins = GSGraph::Checkin.search(:access_token => 'access_token')
+        checkins.each do |checkin|
+          checkin.should be_instance_of(GSGraph::Checkin)
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/collection_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe GSGraph::Collection, '.new' do
+
+  it 'should return an array with pagination info' do
+    mock_graph :get, 'platform/statuses', 'pages/statuses/platform_private', :access_token => 'access_token' do
+      collection = GSGraph::Page.new('platform', :access_token => 'access_token').statuses.collection
+      collection.should be_kind_of(Array)
+      collection.previous.should be_kind_of(Hash)
+      collection.next.should be_kind_of(Hash)
+    end
+  end
+
+  it 'should allow blank data' do
+    patterns = [
+      GSGraph::Collection.new,
+      GSGraph::Collection.new({}),
+      GSGraph::Collection.new({:count => 5}),
+      GSGraph::Collection.new(nil)
+    ]
+    patterns.each do |collection|
+      collection.should be_kind_of(Array)
+      collection.previous.should be_kind_of(Hash)
+      collection.next.should be_kind_of(Hash)
+      collection.should be_blank
+      collection.previous.should be_blank
+      collection.next.should be_blank
+    end
+  end
+
+  it 'should fetch count as total_count' do
+    collection = GSGraph::Collection.new({:count => 5})
+    collection.total_count.should == 5
+  end
+
+  it 'should accept Array' do
+    collection = GSGraph::Collection.new([1, 2, 3])
+    collection.total_count.should == 3
+    collection.should == [1, 2, 3]
+    collection.previous.should be_blank
+    collection.next.should be_blank
+  end
+
+  it 'should raise error for invalid input' do
+    lambda do
+      GSGraph::Collection.new("STRING")
+    end.should raise_error(ArgumentError, 'Invalid collection')
+  end
+
+end

data/spec/gs_graph/comment_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe GSGraph::Comment, '.new' do
+
+  it 'should setup all supported attributes' do
+    attributes = {
+      :id => '12345',
+      :from => {
+        :id => '23456',
+        :name => 'nov matake'
+      },
+      :message => 'hello',
+      :created_time => '2010-01-02T15:37:40+0000'
+    }
+    comment = GSGraph::Comment.new(attributes.delete(:id), attributes)
+    comment.identifier.should   == '12345'
+    comment.from.should         == GSGraph::User.new('23456', :name => 'nov matake')
+    comment.message.should      == 'hello'
+    comment.created_time.should == Time.parse('2010-01-02T15:37:40+0000')
+  end
+
+  it 'should support page as from' do
+    page_comment = GSGraph::Comment.new('12345', :from => {
+      :id => '23456',
+      :name => 'Smart.fm',
+      :category => 'Web Site'
+    })
+    page_comment.from.should == GSGraph::Page.new('23456', :name => 'Smart.fm', :category => 'Web Site')
+  end
+
+end

data/spec/gs_graph/connection_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe GSGraph::Connection, '.new' do
+  it 'should return an array with connection info' do
+    mock_graph :get, 'platform/statuses', 'pages/statuses/platform_private', :access_token => 'access_token' do
+      page = GSGraph::Page.new('platform', :access_token => 'access_token')
+      statuses = page.statuses
+      statuses.should be_kind_of(Array)
+      statuses.collection.should be_kind_of(GSGraph::Collection)
+      statuses.owner.should == page
+      statuses.connection.should == :statuses
+    end
+  end
+end
+
+describe GSGraph::Connection do
+  it 'should be useful for pagenation' do
+    me = GSGraph::User.new('me', :access_token => 'access_token')
+    posts = nil
+    mock_graph :get, 'me/home', 'users/home/me_private', :access_token => 'access_token' do
+      posts = me.home
+      posts.first.created_time.should == Time.parse('2010-04-27T13:06:14+0000')
+      posts.last.created_time.should  == Time.parse('2010-04-27T11:07:48+0000')
+    end
+    mock_graph :get, 'me/home', 'users/home/me_private_previous', :access_token => 'access_token', :params => {
+      :limit => '25',
+      :since => '123456789'
+    } do
+      previous_posts = posts.previous
+      previous_posts.first.created_time.should == Time.parse('2010-04-27T13:23:08+0000')
+      previous_posts.last.created_time.should  == Time.parse('2010-04-27T13:10:56+0000')
+    end
+    mock_graph :get, 'me/home', 'users/home/me_private_next', :access_token => 'access_token', :params => {
+      :limit => '25',
+      :until => '123456789'
+    } do
+      next_posts = posts.next
+      next_posts.first.created_time.should == Time.parse('2010-04-27T11:06:29+0000')
+      next_posts.last.created_time.should  == Time.parse('2010-04-27T09:44:28+0000')
+    end
+  end
+end

data/spec/gs_graph/connections/accounts_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Accounts do
+  describe '#accounts' do
+    context 'when included by GSGraph::User' do
+      context 'when no access_token given' do
+        it 'should raise GSGraph::Unauthorized' do
+          mock_graph :get, 'matake/accounts', 'users/accounts/matake_public', :status => [401, 'Unauthorized'] do
+            lambda do
+              GSGraph::User.new('matake').accounts
+            end.should raise_exception(GSGraph::Unauthorized)
+          end
+        end
+      end
+
+      context 'when access_token is given' do
+        it 'should return accounts as GSGraph::Page or GSGraph::Application' do
+          mock_graph :get, 'matake/accounts', 'users/accounts/matake_private', :access_token => 'access_token' do
+            accounts = GSGraph::User.new('matake', :access_token => 'access_token').accounts
+            accounts.class.should == GSGraph::Connection
+            accounts.first.should == GSGraph::Page.new(
+              '140478125968442',
+              :access_token => 'access_token',
+              :name => 'OAuth.jp',
+              :category => 'Community organization',
+              :perms => [
+                "ADMINISTER",
+                "EDIT_PROFILE",
+                "CREATE_CONTENT",
+                "MODERATE_CONTENT",
+                "CREATE_ADS",
+                "BASIC_ADMIN"
+              ]
+            )
+            accounts.last.should == GSGraph::Application.new(
+              '159306934123399',
+              :access_token => 'access_token',
+              :name => 'Rack::OAuth2 Sample'
+            )
+            accounts[0, 9].each do |account|
+              account.should be_instance_of(GSGraph::Page)
+            end
+            accounts[9, 4].each do |account|
+              account.should be_instance_of(GSGraph::Application)
+            end
+          end
+        end
+
+        context 'when manage_pages permission given' do
+          it 'should has special access_token behalf of the page' do
+            mock_graph :get, 'matake/accounts', 'users/accounts/matake_private_with_manage_pages_permission', :access_token => 'access_token_for_user' do
+              accounts = GSGraph::User.new('matake', :access_token => 'access_token_for_user').accounts
+              accounts.first.should == GSGraph::Page.new(
+                '140478125968442',
+                :access_token => 'access_token_for_oauth_jp',
+                :name => 'OAuth.jp',
+                :category => 'Technology'
+              )
+            end
+          end
+        end
+      end
+    end
+
+    context 'when included by GSGraph::Application' do
+      it 'should return an array of TestUser' do
+        mock_graph :get, 'app/accounts', 'applications/accounts/private', :access_token => 'access_token_for_app' do
+          accounts = GSGraph::Application.new('app', :access_token => 'access_token_for_app').accounts
+          accounts.first.should == GSGraph::TestUser.new(
+            '100002527044219',
+            :access_token => '117950878254050|2.AQA7fQ_BuZqxAiHc.3600.1308646800.0-100002527044219|T1wRNmvnx5j5nw-2x00gZgdBjbo',
+            :login_url => 'https://www.gamestamper.com/platform/test_account_login.php?user_id=100002527044219&n=SOlkQGg6Icr5BeI'
+          )
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/achievements_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Achievements do
+  let(:app) { GSGraph::Application.new('app_id', :access_token => 'app_token') }
+
+  describe '#achievements' do
+    it 'should return an Array of GSGraph::Achievement' do
+      mock_graph :get, 'app_id/achievements', 'applications/achievements/sample', :access_token => 'app_token' do
+        app.achievements.each do |achievement|
+          achievement.should be_instance_of GSGraph::Achievement
+          achievement.access_token.should == 'app_token'
+        end
+      end
+    end
+  end
+
+  describe '#achievement!' do
+    let(:achievement_url) { 'http://fbgraphsample.heroku.com/achievements/1' }
+    it 'should return true' do
+      mock_graph :post, 'app_id/achievements', 'true', :access_token => 'app_token', :params => {
+        :achievement => achievement_url
+      } do
+        app.achievement!(achievement_url).should be_true
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/activities_spec.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe GSGraph::Connections::Activities, '#activities' do
+  context 'when included by GSGraph::User' do
+    context 'when no access_token given' do
+      it 'should raise GSGraph::Unauthorized' do
+        mock_graph :get, 'arjun/activities', 'users/activities/arjun_public', :status => [401, 'Unauthorized'] do
+          lambda do
+            GSGraph::User.new('arjun').activities
+          end.should raise_exception(GSGraph::Unauthorized)
+        end
+      end
+    end
+
+    context 'when access_token is given' do
+      it 'should return activities as GSGraph::Page' do
+        mock_graph :get, 'arjun/activities', 'users/activities/arjun_private', :access_token => 'access_token' do
+          activities = GSGraph::User.new('arjun', :access_token => 'access_token').activities
+          activities.class.should == GSGraph::Connection
+          activities.first.should == GSGraph::Page.new(
+            '378209722137',
+            :access_token => 'access_token',
+            :name => 'Doing Things at the Last Minute',
+            :category => '活動'
+          )
+          activities.each do |activity|
+            activity.should be_instance_of(GSGraph::Page)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/ad_accounts_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::AdAccounts, '#ad_accounts' do
+  context 'when included by GSGraph::User' do
+    context 'when access_token is given' do
+      it 'should return ad_accounts as GSGraph::AdAccount' do
+        mock_graph :get, 'me/adaccounts', 'users/ad_accounts/me_ad_accounts', :access_token => 'access_token' do
+          ad_accounts = GSGraph::User.me('access_token').ad_accounts
+          ad_accounts.size.should == 2
+          ad_accounts.each { |ad_account| ad_account.should be_instance_of(GSGraph::AdAccount) }
+          ad_accounts.first.should == GSGraph::AdAccount.new(
+            "act_108370185937777",
+            :account_id => 108370185937777,
+            :name => "",
+            :account_status => 1,
+            :currency => "USD",
+            :timezone_id => 1,
+            :timezone_name => "America/Los_Angeles",
+            :daily_spend_limit => 5000,
+            :users => [{"uid" => 10000294098888, :permissions => [1,2,3,4,5,7], :role => 1001}],
+            :capabilities => [],
+            :access_token => 'access_token'
+          )
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/ad_campaign_stat_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::AdCampaignStats, '#ad_campaign_stats' do
+  context 'when included by GSGraph::AdAccount' do
+    context 'when access_token is given' do
+      it 'should return ad_campaign_stats as GSGraph::AdCampaignStat' do
+        mock_graph :get, 'act_11223344/adcampaignstats', 'ad_accounts/ad_campaign_stats/test_ad_campaign_stats', :access_token => 'access_token' do
+          ad_campaign_stats = GSGraph::AdAccount.new('act_11223344', :access_token => 'access_token').ad_campaign_stats
+
+          ad_campaign_stats.size.should == 2
+          ad_campaign_stats.each { |ad_campaign_stat| ad_campaign_stat.should be_instance_of(GSGraph::AdCampaignStat) }
+          ad_campaign_stats.first.should == GSGraph::AdCampaignStat.new(
+            "6002647797777/stats/0/1315507793",
+            :campaign_id => 6002647797777,
+            :start_time => nil,
+            :end_time => Time.parse("2011-09-08T18:49:53+0000"),
+            :impressions => 232641,
+            :clicks => 534,
+            :spent => 18885,
+            :social_impressions => 22676,
+            :social_clicks => 81,
+            :social_spent => 1548,
+            :unique_impressions => 0,
+            :social_unique_impressions => 0,
+            :unique_clicks => 0,
+            :social_unique_clicks => 0,
+            :actions => 140,
+            :connections => 0,
+            :access_token => 'access_token'
+          )
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/ad_campaigns_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+describe GSGraph::Connections::AdCampaigns, '#ad_campaign!' do
+  context 'when included by GSGraph::AdAccount' do
+    it 'should return generated ad_account' do
+      mock_graph :post, 'act_22334455/adcampaigns', 'ad_accounts/ad_campaigns/post_with_valid_access_token' do
+        ad_campaign = GSGraph::AdAccount.new('act_22334455', :access_token => 'valid').ad_campaign!(
+          :name => "Campaign 1",
+          :daily_budget => 500
+        )
+
+        ad_campaign.identifier.should == "6004167532222"
+      end
+    end
+
+    it 'should handle the redownload parameter' do
+      mock_graph :post, 'act_22334455/adcampaigns', 'ad_accounts/ad_campaigns/post_with_redownload' do
+        ad_campaign = GSGraph::AdAccount.new('act_22334455', :access_token => 'valid').ad_campaign!(
+          :name => "Campaign 1",
+          :daily_budget => 500,
+          :redownload => true
+        )
+
+        ad_campaign.identifier.should == "6004167532222"
+        ad_campaign.account_id.should == 22334455
+        ad_campaign.name.should == "Campaign 1"
+        ad_campaign.daily_budget.should == 500
+        ad_campaign.campaign_status.should == 2
+        ad_campaign.daily_imps.should == 0
+        ad_campaign.start_time.should == Time.at(1330282800)
+        ad_campaign.end_time.should == Time.at(1330588800)
+        ad_campaign.updated_time.should == Time.at(1329850926)
+      end
+    end
+  end
+end
+

data/spec/gs_graph/connections/ad_connection_objects_spec.rb

@@ -0,0 +1,20 @@
+describe GSGraph::Connections::AdConnectionObjects, '#ad_connection_objects' do
+  context 'when included by GSGraph::AdAccount' do
+    context 'when access_token is given' do
+      it 'should return ad_connection_objects as GSGraph::AdConnectionObject' do
+        mock_graph :get, 'act_11223344/connectionobjects', 'ad_accounts/ad_connection_objects/test_connection_objects', :access_token => 'access_token' do
+          ad_connections = GSGraph::AdAccount.new("act_11223344", :access_token => 'access_token').connection_objects
+          ad_connections.size.should == 3
+
+          ad_connections.first.identifier.should == 354545238888
+          ad_connections.first.name.should == "MyPage"
+          ad_connections.first.url.should == "http://www.gamestamper.com/MyPage"
+          ad_connections.first.type.should == 1
+          ad_connections.first.picture.should == "http://profile.ak.fbcdn.net/hprofile-ak-snc4/41591_354545238178_3195000_s.jpg"
+          ad_connections.first.tabs.keys.size.should == 5
+          ad_connections.first.tabs["http://www.gamestamper.com/MyPage?sk=wall"].should == "Wall"
+        end
+      end
+    end
+  end
+end