gs_graph 2.6.5

data/spec/gs_graph/connections/ad_creatives_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::AdGroups, '#ad_creatives' do
+  context 'when included by GSGraph::AdGroup' do
+    context 'when access_token is given' do
+      it 'should return ad_creatives as GSGraph::AdCreative' do
+        mock_graph :get, '22334455/adcreatives', 'ad_groups/ad_creatives/22334455_ad_creatives', :access_token => 'access_token' do
+          ad_creatives = GSGraph::AdGroup.new('22334455', :access_token => 'access_token').ad_creatives
+          ad_creatives.size.should == 1 
+          ad_creative = ad_creatives.first 
+          ad_creative.identifier.should == "6003590469668"
+          ad_creative.view_tag.should == ""
+          ad_creative.alt_view_tags.should == []
+          ad_creative.creative_id.should == "6003590469668"
+          ad_creative.type.should == 1
+          ad_creative.title.should == "Some Creative"
+          ad_creative.body.should == "The Body"
+          ad_creative.image_hash.should == "4c34b48cdcbf5dd3055acb717343a9d6"
+          ad_creative.link_url.should == "http://www.google.com/"
+          ad_creative.name.should == "Creative Name"
+          ad_creative.run_status.should == 1
+          ad_creative.preview_url.should == "http://www.gamestamper.com/ads/api/creative_preview.php?cid=6003590469668"
+          ad_creative.count_current_adgroups.should == 1
+          ad_creative.image_url.should == "https://www.google.com/image.png"
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/ad_group_stat_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::AdGroupStats, '#ad_group_stats' do
+  context 'when included by GSGraph::AdAccount' do
+    context 'when access_token is given' do
+      it 'should return ad_group_stats as GSGraph::AdGroupStat' do
+        mock_graph :get, 'act_11223344/adgroupstats', 'ad_accounts/ad_group_stats/test_ad_group_stats', :access_token => 'access_token' do
+          ad_group_stats = GSGraph::AdAccount.new('act_11223344', :access_token => 'access_token').ad_group_stats
+
+          ad_group_stats.size.should == 3
+          ad_group_stats.total_count.should == 3081
+          ad_group_stats.each { |ad_group_stat| ad_group_stat.should be_instance_of(GSGraph::AdGroupStat) }
+          ad_group_stats.first.should == GSGraph::AdGroupStat.new(
+            "6002647798444/stats/0/1315607403",
+            :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,
+            :adgroup_id => 6002647798444,
+            :start_time => nil,
+            :end_time => "2011-09-09T22:30:03+0000",
+            :access_token => "access_token"
+          )
+        end
+      end
+
+      context 'when paginating' do
+        it 'should use ad_group_stats as method name' do
+          mock_graph :get, 'act_11223344/adgroupstats', 'ad_accounts/ad_group_stats/test_ad_group_stats', :access_token => 'access_token' do
+            ad_group_stats = GSGraph::AdAccount.new('act_11223344', :access_token => 'access_token').ad_group_stats
+            ad_group_stats.owner.should_receive :ad_group_stats
+            ad_group_stats.next
+          end
+        end
+
+        it 'should use adcampaignstats as connection name' do
+          mock_graph :get, 'act_11223344/adgroupstats', 'ad_accounts/ad_group_stats/test_ad_group_stats', :access_token => 'access_token' do
+            ad_group_stats = GSGraph::AdAccount.new('act_11223344', :access_token => 'access_token').ad_group_stats
+            expect { ad_group_stats.next }.to request_to 'act_11223344/adgroupstats'
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/gs_graph/connections/ad_groups_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::AdGroups, '#ad_groups' do
+  context 'when included by GSGraph::AdCampaign' do
+    context 'when access_token is given' do
+      it 'should return ad_groups as GSGraph::AdGroup' do
+        mock_graph :get, '22334455/adgroups', 'ad_campaigns/ad_groups/22334455_ad_groups', :access_token => 'access_token' do
+          ad_groups = GSGraph::AdCampaign.new('22334455', :access_token => 'access_token').ad_groups
+          ad_groups.size.should == 2
+          ad_groups.each { |ad_group| ad_group.should be_instance_of(GSGraph::AdGroup) }
+          ad_groups.first.should == GSGraph::AdGroup.new(
+            "6003570493888",
+            :access_token => 'access_token',
+            :ad_id => 6003570493888,
+            :campaign_id => 22334455,
+            :name => "My Ad 1",
+            :adgroup_status => 1,
+            :bid_type => 1,
+            :max_bid => "120",
+            :adgroup_id => 6003570493888,
+            :end_time => nil,
+            :start_time => nil,
+            :updated_time => Time.parse("2011-08-17T20:41:39+0000"),
+            :bid_info => {"1" => "120"},
+            :creative_ids => [6003570493444],
+            :targeting => {
+              "age_min" => 18,
+              "age_max" => 65,
+              "countries" => ["US"],
+              "education_statuses" => [3],
+              "college_networks" => [
+                {"name" => "Emory", "id" => "16777243"},
+                {"name" => "Georgia Tech", "id" => "16777345"}
+              ]
+            }
+          )
+        end
+      end
+    end
+  end
+end
+
+describe GSGraph::Connections::AdGroups, '#ad_group!' do
+  context 'when included by GSGraph::AdAccount' do
+    it 'should return generated ad_group' do
+      mock_graph :post, 'act_22334455/adgroups', 'ad_accounts/ad_groups/post_with_valid_access_token' do
+        ad_group = GSGraph::AdAccount.new('act_22334455', :access_token => 'valid').ad_group!(
+          :name => "Test Ad 1",
+          :campaign_id => 66778899,
+          :bid_type => 1,
+          :max_bid => 100,
+          :start_time => Time.parse("2011-09-10T12:00:00+00:00"),
+          :end_time => Time.parse("2011-09-20T16:00:00-04:00")
+        )
+
+        ad_group.identifier.should == 112233445566
+        ad_group.campaign_id.should == 66778899
+        ad_group.name.should == "Test Ad 1"
+        ad_group.bid_type.should == 1
+        ad_group.max_bid.should == 100
+        ad_group.start_time.should == Time.parse("2011-09-10T12:00:00+00:00")
+        ad_group.end_time.should == Time.parse("2011-09-20T16:00:00-04:00")
+      end
+    end
+
+    it 'should handle the redownload parameter' do
+      mock_graph :post, 'act_22334455/adgroups', 'ad_accounts/ad_groups/post_with_redownload' do
+        ad_group = GSGraph::AdAccount.new('act_22334455', :access_token => 'valid').ad_group!(
+          :name => "Test Ad 2",
+          :campaign_id => 11223344,
+          :bid_type => 1,
+          :max_bid => 100,
+          :start_time => Time.parse("2012-02-20T00:00:00Z"),
+          :end_time => Time.parse("2012-02-23T00:00:00Z"),
+          :redownload => true
+        )
+
+        ad_group.identifier.should == "22334455"
+        ad_group.campaign_id.should == 11223344
+        ad_group.name.should == "Test Ad 2"
+        ad_group.bid_type.should == 1
+        ad_group.max_bid.should == 100
+        ad_group.start_time.should == Time.parse("2012-02-20T00:00:00Z")
+        ad_group.end_time.should == Time.parse("2012-02-23T00:00:00Z")
+
+        # ad_status is not sent, only received
+        ad_group.adgroup_status.should == 4
+      end
+    end
+  end
+end
+

data/spec/gs_graph/connections/ad_previews_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::AdPreviews, '#ad_previews' do
+  context 'when included by GSGraph::AdAccount' do
+    context 'when access_token is given' do
+      it 'should return ad_preview as GSGraph::AdPreview' do
+        mock_graph :post, 'act_123456789/generatepreviews', 'ad_accounts/previews/test_ad_previews'  do
+          ad_account = GSGraph::AdAccount.new('act_123456789', :access_token => 'access_token')
+          ad_preview = ad_account.ad_previews(:access_token => 'access_token', :creative => {})
+          ad_preview.should be_instance_of(GSGraph::AdPreview)
+          ad_preview.preview_data[:body].should == '<h1>hello world</h1>'
+        end
+      end
+    end
+  end
+end
+
+

data/spec/gs_graph/connections/admins_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Admins do
+  let(:page) { GSGraph::Page.new('GSGraph', :access_token => 'page_token') }
+  context 'when given user is admin' do
+    it 'should be true' do
+      mock_graph :get, 'GSGraph/admins/matake', 'pages/admins/sample', :access_token => 'page_token' do
+        page.admin?(GSGraph::User.new('matake')).should be_true
+      end
+    end
+  end
+
+  context 'otherwise' do
+    it 'should be false' do
+      mock_graph :get, 'GSGraph/admins/nov.matake', 'pages/admins/blank', :access_token => 'page_token' do
+        page.admin?(GSGraph::User.new('nov.matake')).should be_false
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/albums_spec.rb

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe GSGraph::Connections::Albums, '#albums' 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/albums', 'users/albums/matake_public', :status => [401, 'Unauthorized'] do
+          lambda do
+            GSGraph::User.new('matake').albums
+          end.should raise_exception(GSGraph::Unauthorized)
+        end
+      end
+    end
+
+    context 'when access_token is given' do
+      it 'should return albums as GSGraph::Album' do
+        mock_graph :get, 'matake/albums', 'users/albums/matake_private', :access_token => 'access_token' do
+          albums = GSGraph::User.new('matake', :access_token => 'access_token').albums
+          albums.first.should == GSGraph::Album.new(
+            '19351532276',
+            :access_token => 'access_token',
+            :from => {
+              :id => '579612276',
+              :name => 'Nov Matake'
+            },
+            :name => 'モバイルアップロード',
+            :description => 'hello facebookers!',
+            :link => 'http://www.gamestamper.com/album.php?aid=25463&id=579612276',
+            :location => 'NYC',
+            :count => 3,
+            :privacy => 'everyone',
+            :created_time => '2008-07-27T11:38:15+0000',
+            :updated_time => '2009-02-07T16:09:53+0000'
+          )
+          albums.each do |album|
+            album.should be_instance_of(GSGraph::Album)
+          end
+        end
+      end
+    end
+  end
+end
+
+describe GSGraph::Connections::Albums, '#album!' do
+  context 'when included by GSGraph::User' do
+    it 'should return generated album' do
+      mock_graph :post, 'matake/albums', 'users/albums/post_with_valid_access_token', :access_token => 'valid', :params => {
+        :name => 'GSGraph test',
+        :message => 'test test test'
+      } do
+        album = GSGraph::User.new('matake', :access_token => 'valid').album!(
+          :name => 'GSGraph test',
+          :message => 'test test test'
+        )
+        album.identifier.should == 401096332276
+        album.access_token.should == 'valid'
+        album.name.should == 'GSGraph test'
+        album.description.should == 'test test test'
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/app_notifications_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::AppNotifications do
+  let(:app) do
+    _app_ = GSGraph::Application.new('app_id', :secret => 'app_secret')
+    _app_.should_receive(:get_access_token).and_return(
+      Rack::OAuth2::AccessToken::Legacy.new(:access_token => 'app_access_token')
+    )
+    _app_
+  end
+
+  describe '#notify!' do
+    it 'should return success json' do
+      mock_graph :post, 'matake/notifications', 'success', :params => {
+        :template => 'hello'
+      }, :access_token => 'app_access_token' do
+        user = GSGraph::User.new('matake')
+        response = app.notify! user, :template => 'hello'
+        response.should == {'success' => true}
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/app_requests_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::AppRequests do
+  describe '#app_requests' do
+    it 'should return an Array of GSGraph::AppRequest' do
+      mock_graph :get, 'me/apprequests', 'users/app_requests/me_private', :access_token => 'access_token' do
+        app_requests = GSGraph::User.me('access_token').app_requests
+        app_requests.each do |app_request|
+          app_request.should be_instance_of GSGraph::AppRequest
+        end
+      end
+    end
+  end
+
+  describe '#app_request!' do
+    it 'should return GSGraph::AppRequest' do
+      mock_graph :post, 'me/apprequests', 'users/app_requests/created', :access_token => 'access_token', :params => {
+        :message => 'Message', :data => 'Data'
+      } do
+        app_request = GSGraph::User.me('access_token').app_request! :message => 'Message', :data => 'Data'
+        app_request.should be_instance_of GSGraph::AppRequest
+        app_request.identifier.should == "158192394305537_579612276"
+        app_request.message.should == 'Message'
+        app_request.data.should == 'Data'
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/attending_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Attending do
+  let(:event) do
+    GSGraph::Event.new('smartday', :access_token => 'access_token')
+  end
+
+  describe '#attending' do
+    it 'should return attending users as GSGraph::User' do
+      mock_graph :get, 'smartday/attending', 'events/attending/smartday_private', :access_token => 'access_token' do
+        event.attending.each do |user|
+          user.should be_instance_of(GSGraph::User)
+        end
+      end
+    end
+  end
+
+  describe '#attending?' do
+    context 'when attending' do
+      it 'should return true' do
+        mock_graph :get, 'smartday/attending/uid', 'events/invited/attending', :access_token => 'access_token' do
+          event.attending?(
+            GSGraph::User.new('uid')
+          ).should be_true
+        end
+      end
+    end
+
+    context 'otherwise' do
+      it 'should return false' do
+        mock_graph :get, 'smartday/attending/uid', 'empty', :access_token => 'access_token' do
+          event.attending?(
+            GSGraph::User.new('uid')
+          ).should be_false
+        end
+      end
+    end
+  end
+
+  describe '#attend!' do
+    it 'should return true' do
+      mock_graph :post, 'smartday/attending', 'events/attending/post_with_valid_access_token', :access_token => 'access_token' do
+        event.attend!.should be_true
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/banned_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Banned do
+  let(:app)  { GSGraph::Application.new('app_id', :secret => 'app_secret') }
+  let(:user) { GSGraph::User.new('uid') }
+
+  describe '#banned' do
+    it 'should return an Array of GSGraph::User' do
+      mock_graph :post, 'oauth/access_token', 'app_token_response' do
+        mock_graph :get, 'app_id/banned', 'applications/banned/list', :access_token => 'app_token' do
+          users = app.banned
+          users.each do |user|
+            user.should be_a GSGraph::User
+          end
+        end
+      end
+    end
+  end
+
+  describe '#banned?' do
+    context 'when banned' do
+      it 'should retrun true' do
+        mock_graph :post, 'oauth/access_token', 'app_token_response' do
+          mock_graph :get, 'app_id/banned/uid', 'applications/banned/banned_user', :access_token => 'app_token' do
+            app.banned?(user).should be_true
+          end
+        end
+      end
+    end
+
+    context 'otherwise' do
+      it 'should retrun false' do
+        mock_graph :post, 'oauth/access_token', 'app_token_response' do
+          mock_graph :get, 'app_id/banned/uid', 'empty', :access_token => 'app_token' do
+            app.banned?(user).should be_false
+          end
+        end
+      end
+    end
+  end
+
+  describe '#ban!' do
+    it 'should return true' do
+      mock_graph :post, 'oauth/access_token', 'app_token_response' do
+        mock_graph :post, 'app_id/banned', 'true', :access_token => 'app_token', :params => {
+          :uid => 'uid'
+        } do
+          app.ban!(user).should be_true
+        end
+      end
+    end
+  end
+
+  describe '#unban!' do
+    it 'should return true' do
+      mock_graph :post, 'oauth/access_token', 'app_token_response' do
+        mock_graph :delete, 'app_id/banned/uid', 'true', :access_token => 'app_token' do
+          app.unban!(user).should be_true
+        end
+      end
+    end
+  end
+end