gs_graph 2.6.5

data/spec/gs_graph/connections/promotable_posts_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::PromotablePosts do
+  describe '#promotable_posts' do
+    it 'should return promotable posts the user created as GSGraph::Post' do
+      mock_graph :get, 'GSGraph/promotable_posts', 'pages/promotable_posts/sample', :access_token => 'access_token' do
+        posts = GSGraph::Page.new('GSGraph', :access_token => 'access_token').promotable_posts
+        posts.class.should == GSGraph::Connection
+        posts.count.should == 4
+        posts.each.with_index do |post, index|
+          post.should be_instance_of GSGraph::PromotablePost
+          case index
+          when 0
+            post.is_published.should be_false
+            post.scheduled_publish_time.should == Time.at(1352473200)
+          else
+            post.is_published.should be_true
+            post.scheduled_publish_time.should be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/question_options_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::QuestionOptions, '#options' do
+  context 'when included by GSGraph::Question' do
+    it 'should return options as GSGraph::QuestionOption' do
+      mock_graph :get, '12345/options', 'questions/options/matake_private', :access_token => 'access_token' do
+        question_options = GSGraph::Question.new('12345', :access_token => 'access_token').question_options
+        question_options.each do |question_option|
+          question_option.should be_instance_of(GSGraph::QuestionOption)
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/questions_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Questions do
+  describe '#questions' do
+    it 'should return an Array of Questions' do
+      mock_graph :get, 'me/questions', 'users/questions/sample', :access_token => 'access_token' do
+        questions = GSGraph::User.me('access_token').questions
+        questions.class.should == GSGraph::Connection
+        questions.each do |question|
+          question.should be_instance_of(GSGraph::Question)
+        end
+      end
+    end
+  end
+
+  describe '#question!' do
+    it 'should return GSGraph::Question without cached question_options collection' do
+      mock_graph :post, 'me/questions', 'users/questions/created', :params => {
+        :question => 'Do you like gs_graph?',
+        :options => ['Yes', 'Yes!', 'Yes!!'].to_json
+      }, :access_token => 'access_token' do
+        question = GSGraph::User.me('access_token').question!(
+          :question => 'Do you like gs_graph?',
+          :options => ['Yes', 'Yes!', 'Yes!!']
+        )
+        question.should be_instance_of(GSGraph::Question)
+        expect { question.question_options }.to request_to "#{question.identifier}/options"
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/reach_estimates_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::ReachEstimates, '#reach_estimates' do
+  context 'when included by GSGraph::AdAccount' do
+    context 'when access_token is given' do
+      it 'should return reach_estimates as GSGraph::ReachEstimate' do
+        mock_graph :get, 'act_123456789/reachestimate', 'ad_accounts/reach_estimates/test_reach_estimates', :params => {
+          :targeting_spec => {:country => ["US"]}.to_json
+        }, :access_token => 'access_token' do
+          ad_account = GSGraph::AdAccount.new('act_123456789')
+          reach_estimate = ad_account.reach_estimates(:access_token => 'access_token', :targeting_spec => {:country => ["US"]})
+          reach_estimate.should be_instance_of(GSGraph::ReachEstimate)
+        end
+      end
+    end
+  end
+end
+

data/spec/gs_graph/connections/roles_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Roles do
+  let(:app) do
+    GSGraph::Application.new('app_id', :secret => 'app_secret')
+  end
+
+  describe '#roles' do
+    it 'should return an Array of GSGraph::Role' do
+      mock_graph :post, 'oauth/access_token', 'app_token_response' do
+        mock_graph :get, 'app_id/roles', 'applications/roles/list', :access_token => 'app_token' do
+          roles = app.roles
+          roles.should be_instance_of GSGraph::Connection
+          roles.each do |role|
+            role.should be_instance_of GSGraph::Role
+          end
+          roles.first.user.should == GSGraph::User.new('579612276')
+          roles.first.application.== GSGraph::Application.new('210798282372757')
+          roles.first.role.should == 'administrators'
+        end
+      end
+    end
+  end
+
+  {
+    :admin!         => 'administrators',
+    :developer!     => 'developers',
+    :tester!        => 'testers',
+    :insights_user! => 'insights users'
+  }.each do |method, role|
+    describe "##{method}" do
+      it 'should return true' do
+        mock_graph :post, 'app_id/roles', 'true', :access_token => 'admin_user_token', :params => {
+          :user => 'new_admin_uid',
+          :role => role
+        } do
+          app.send(
+            method,
+            GSGraph::User.new('new_admin_uid'),
+            :access_token => 'admin_user_token'
+          ).should be_true
+        end
+      end
+    end
+  end
+
+  describe '#unrole!' do
+    it 'should return true' do
+      mock_graph :delete, 'app_id/roles', 'true', :access_token => 'role_owner_token', :params => {
+        :user => 'role_owner_uid'
+      } do
+        app.unrole!(
+          GSGraph::User.new('role_owner_uid'),
+          :access_token => 'role_owner_token'
+        ).should be_true
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/scores_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Scores do
+  let(:user) { GSGraph::User.new('matake', :access_token => 'user_access_token') }
+  let(:app) { GSGraph::Application.new('GSGraph', :access_token => 'app_access_token') }
+
+  describe '#scores' do
+    it 'should return an Array of Score' do
+      mock_graph :get, 'matake/scores', 'users/scores/sample', :access_token => 'user_access_token' do
+        scores = user.scores
+        scores.should be_a Array
+        scores.should_not be_blank
+        scores.each do |score|
+          score.should be_instance_of GSGraph::Score
+          score.user.should be_instance_of GSGraph::User
+          score.application.should be_instance_of GSGraph::Application
+          score.score.should be_a Integer
+        end
+      end
+    end
+  end
+
+  describe '#score!' do
+    it 'should return true' do
+      mock_graph :post, 'matake/scores', 'true', :access_token => 'app_access_token', :params => {
+        :score => '10'
+      } do
+        user.score!(10, :access_token => app.access_token).should be_true
+      end
+    end
+  end
+
+  describe '#unscore!' do
+    it 'should return true' do
+      mock_graph :delete, 'matake/scores', 'true', :access_token => 'app_access_token' do
+        user.unscore!(:access_token => app.access_token).should be_true
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/senders_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Senders, '#senders' do
+  it 'should return senders as GSGraph::User' do
+    mock_graph :get, '12345/senders', 'thread/senders/private', :params => {:no_cache => 'true'}, :access_token => 'access_token' do
+      senders = GSGraph::Thread.new(12345, :access_token => 'access_token').senders(:no_cache => true)
+      senders.each do |sender|
+        sender.should be_instance_of(GSGraph::User)
+      end
+    end
+  end
+
+  describe 'cached messages' do
+    context 'when cached' do
+      let(:thread) { GSGraph::Thread.new(12345, :access_token => 'access_token', :senders => {}) }
+
+      it 'should use cache' do
+        lambda do
+          thread.senders
+        end.should_not request_to '12345/senders?access_token=access_token'
+      end
+
+      context 'when options are specified' do
+        it 'should not use cache' do
+          lambda do
+            thread.senders(:no_cache => true)
+          end.should request_to '12345/senders?access_token=access_token&no_cache=true'
+        end
+      end
+    end
+
+    context 'otherwise' do
+      let(:thread) { GSGraph::Thread.new(12345, :access_token => 'access_token') }
+
+      it 'should not use cache' do
+        lambda do
+          thread.senders
+        end.should request_to '12345/senders?access_token=access_token'
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/settings_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Settings do
+
+  describe '#settings' do
+    subject do
+      mock_graph :get, 'sample/settings', 'pages/settings/sample', :access_token => 'page_token' do
+        GSGraph::Page.new('sample').settings(:access_token => 'page_token')
+      end
+    end
+
+    it do
+      should == [
+        :users_can_post,
+        :users_can_post_photos,
+        :users_can_post_videos
+      ]
+    end
+  end
+
+  describe 'setting specific methods' do
+    let(:page) { GSGraph::Page.new('page_id', :access_token => 'page_token') }
+
+    before do
+      mock_graph :get, 'page_id/settings', 'pages/settings/all_enabled', :access_token => 'page_token' do
+        page.settings # cache settings
+      end
+    end
+
+    GSGraph::Connections::Settings::AVAILABLE_SETTINGS.each do |setting|
+      describe "##{setting}?" do
+        it { page.send(:"#{setting}?").should be_true }
+
+        context 'when no_cache specified' do
+          it 'should request API' do
+            expect { page.send(:"#{setting}?", :no_cache => true) }.to request_to 'page_id/settings'
+          end
+        end
+      end
+
+      describe "#{setting}!" do
+        it "should enable it" do
+          mock_graph :post, 'page_id/settings', 'true', :access_token => 'page_token', :params => {
+            :setting => setting.to_s.upcase, :value => 'true'
+          } do
+            page.send(:"#{setting}!").should be_true
+          end
+        end
+      end
+
+      describe "#{setting.to_s.sub('can', 'cannot')}!" do
+        it "should disable it" do
+          mock_graph :post, 'page_id/settings', 'true', :access_token => 'page_token', :params => {
+            :setting => setting.to_s.upcase, :value => 'false'
+          } do
+            page.send(:"#{setting.to_s.sub('can', 'cannot')}!").should be_true
+          end
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/statuses_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Statuses, '#statuses' 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/statuses', 'users/statuses/arjun_public', :status => [401, 'Unauthorized'] do
+          lambda do
+            GSGraph::User.new('arjun').statuses
+          end.should raise_exception(GSGraph::Unauthorized)
+        end
+      end
+    end
+
+    context 'when access_token is given' do
+      it 'should return statuses as GSGraph::Status' do
+        mock_graph :get, 'arjun/statuses', 'users/statuses/arjun_private', :access_token => 'access_token' do
+          statuses = GSGraph::User.new('arjun', :access_token => 'access_token').statuses
+          statuses.first.should == GSGraph::Status.new(
+            '113559395341627',
+            :access_token => 'access_token',
+            :from => {
+              :id => '7901103',
+              :name => 'Arjun Banker'
+            },
+            :message => 'http://www.gamestamper.com/photo.php?pid=60538827&l=79b44ffb74&id=7901103',
+            :updated_time => '2010-04-21T21:10:16+0000'
+          )
+          statuses.each do |status|
+            status.should be_instance_of(GSGraph::Status)
+          end
+        end
+      end
+    end
+  end
+
+  context 'when included by GSGraph::Page' do
+    context 'when no access_token given' do
+      it 'should raise GSGraph::Unauthorized' do
+        mock_graph :get, 'platform/statuses', 'pages/statuses/platform_public', :status => [401, 'Unauthorized'] do
+          lambda do
+            GSGraph::Page.new('platform').statuses
+          end.should raise_exception(GSGraph::Unauthorized)
+        end
+      end
+    end
+
+    context 'when access_token is given' do
+      it 'should return statuses as GSGraph::Status' do
+        mock_graph :get, 'platform/statuses', 'pages/statuses/platform_private', :access_token => 'access_token' do
+          statuses = GSGraph::Page.new('platform', :access_token => 'access_token').statuses
+          statuses.first.should == GSGraph::Status.new(
+            '111081598927600',
+            :access_token => 'access_token',
+            :from => {
+              :id => '19292868552',
+              :name => 'Facebook Platform',
+              :category => 'Technology'
+            },
+            :message => 'Here\'s more information on the new social plugins announced at f8 today - http://bit.ly/db8ahS',
+            :updated_time => '2010-04-21T20:17:04+0000'
+          )
+          statuses.each do |status|
+            status.should be_instance_of(GSGraph::Status)
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/gs_graph/connections/subscribed_to_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::SubscribedTo do
+  it 'should return subscribees as GSGraph::User' do
+    mock_graph :get, 'me/subscribedto', 'users/subscribed_to/sample', :access_token => 'access_token' do
+      subscribees = GSGraph::User.me('access_token').subscribed_to
+      subscribees.each do |subscribee|
+        subscribee.should be_instance_of GSGraph::User
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/subscribers_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Subscribers do
+  it 'should return subscribers as GSGraph::User' do
+    mock_graph :get, 'me/subscribers', 'users/subscribers/sample', :access_token => 'access_token' do
+      subscribers = GSGraph::User.me('access_token').subscribers
+      subscribers.each do |subscriber|
+        subscriber.should be_instance_of GSGraph::User
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/subscriptions_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Subscriptions, '#subscriptions' do
+  context 'when included by GSGraph::Application' do
+    context 'when access_token is given' do
+      it 'should return liked pages as GSGraph::Page' do
+        mock_graph :get, 'gs_graph/subscriptions', 'applications/subscriptions/gs_graph_private', :access_token => 'access_token' do
+          subscriptions = GSGraph::Application.new('gs_graph', :access_token => 'access_token').subscriptions
+          subscriptions.each do |subscription|
+            subscription.should be_instance_of(GSGraph::Subscription)
+          end
+        end
+      end
+    end
+  end
+end
+
+describe GSGraph::Connections::Subscriptions, '#subscribe!' do
+  before do
+    @app = GSGraph::Application.new('gs_graph', :access_token => 'access_token')
+  end
+
+  it 'should POST to /:app_id/subscriptions' do
+    lambda do
+      @app.subscribe!(
+        :object => "user",
+        :fields => "name,email",
+        :callback_url => "http://fbgraphsample.heroku.com/subscription",
+        :verify_token => "Define by yourself"
+      )
+    end.should request_to 'gs_graph/subscriptions', :post
+  end
+end
+
+describe GSGraph::Connections::Subscriptions, '#unsubscribe!' do
+  before do
+    @app = GSGraph::Application.new('gs_graph', :access_token => 'access_token')
+  end
+
+  it 'should DELETE /:app_id/subscriptions' do
+    mock_graph :delete, 'gs_graph/subscriptions', 'true', :params => {:object => 'user'}, :access_token => 'access_token' do
+      @app.unsubscribe!(
+        :object => 'user'
+      )
+    end
+  end
+end