gs_graph 2.6.5

data/spec/gs_graph/connections/blocked_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Blocked do
+  let(:page) { GSGraph::Page.new(117513961602338, :access_token => 'access_token') }
+  let(:user) { GSGraph::User.new(579612276) }
+
+  describe '#blocked' do
+    it 'should return blocked users as GSGraph::User' do
+      mock_graph :get, '117513961602338/blocked', 'pages/blocked/index', :access_token => 'access_token' do
+        users = page.blocked
+        users.each do |user|
+          user.should be_a GSGraph::User
+        end
+      end
+    end
+  end
+
+  describe '#blocked?' do
+    context 'when blocked' do
+      it 'should retrun true' do
+        mock_graph :get, '117513961602338/blocked/579612276', 'pages/blocked/show_blocked', :access_token => 'access_token' do
+          page.blocked?(user).should be_true
+        end
+      end
+    end
+
+    context 'otherwise' do
+      it 'should retrun false' do
+        mock_graph :get, '117513961602338/blocked/579612276', 'pages/blocked/show_non_blocked', :access_token => 'access_token' do
+          page.blocked?(user).should be_false
+        end
+      end
+    end
+  end
+
+  describe '#block!' do
+    it 'should return blocked users as GSGraph::User' do
+      mock_graph :post, '117513961602338/blocked', 'pages/blocked/create', :access_token => 'access_token', :params => {
+        :uid => '579612276'
+      } do
+        blocked = page.block! user
+        blocked.each do |user|
+          user.should be_a GSGraph::User
+        end
+      end
+    end
+  end
+
+  describe '#unblock!' do
+    it 'should return true' do
+      mock_graph :delete, '117513961602338/blocked/579612276', 'true', :access_token => 'access_token' do
+        page.unblock!(user).should be_true
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/books_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Books, '#books' 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/books', 'users/books/matake_public', :status => [401, 'Unauthorized'] do
+          lambda do
+            GSGraph::User.new('matake').books
+          end.should raise_exception(GSGraph::Unauthorized)
+        end
+      end
+    end
+
+    context 'when access_token is given' do
+      it 'should return books as GSGraph::Page' do
+        mock_graph :get, 'matake/books', 'users/books/matake_private', :access_token => 'access_token' do
+          books = GSGraph::User.new('matake', :access_token => 'access_token').books
+          books.first.should == GSGraph::Page.new(
+            '102253616477130',
+            :access_token => 'access_token',
+            :name => 'Momo Michael Ende',
+            :category => 'Unknown'
+          )
+          books.each do |book|
+            book.should be_instance_of(GSGraph::Page)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/broad_targeting_categories_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::BroadTargetingCategories, '#broad_targeting_categories' do
+  context 'when included by GSGraph::AdAccount' do
+    context 'when access_token is given' do
+      it 'should return broad_targeting_categories as GSGraph::BroadTargetingCategory' do
+        mock_graph :get, 'act_22334455/broadtargetingcategories', 'ad_accounts/broad_targeting_categories/test_bct', :access_token => 'access_token' do
+          bcts = GSGraph::AdAccount.new("act_22334455").broad_targeting_categories(:access_token => 'access_token')
+          bcts.size.should == 3
+          bcts.each {|x| x.should be_instance_of(GSGraph::BroadTargetingCategory)}
+          bcts[0].identifier.should == 6002714885172
+          bcts[0].name.should == "Cooking"
+          bcts[0].parent_category.should == "Activities"
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/checkins_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Checkins do
+  describe '#checkins' do
+    context 'when included by GSGraph::User' do
+      context 'when no access_token given' do
+        it 'should raise GSGraph::Unauthorized' do
+          mock_graph :get, 'mattt/checkins', 'users/checkins/mattt_public', :status => [401, 'Unauthorized'] do
+            lambda do
+              GSGraph::User.new('mattt').checkins
+            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, 'mattt/checkins', 'users/checkins/mattt_private', :access_token => 'access_token' do
+            checkins = GSGraph::User.new('mattt', :access_token => 'access_token').checkins
+            checkins.first.should == GSGraph::Checkin.new(
+              '696876187499',
+              :access_token => 'access_token',
+              :from => {
+                :id => '12820552',
+                :name => 'Roger Pincombe'
+              },
+              :tags => {
+                :data => [{
+                  :id => '4810308',
+                  :name => 'Mattt Thompson'
+                }]
+              },
+              :message => 'Checking out Austin, TX',
+              :place => {
+                :id => '120454134658381',
+                :name => 'Gowalla HQ',
+                :location => {
+                  :latitude => 30.26876,
+                  :longitude => -97.74962
+                }
+              },
+              :application => {
+                :id => '6628568379',
+                :name => 'Facebook for iPhone'
+              },
+              :created_time => '2010-09-08T00:09:25+0000'
+            )
+            checkins.each do |checkin|
+              checkin.should be_instance_of(GSGraph::Checkin)
+            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, 'gowalla/checkins', 'pages/checkins/gowalla_public', :status => [401, 'Unauthorized'] do
+            lambda do
+              GSGraph::Page.new('gowalla').checkins
+            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, 'gowalla/checkins', 'pages/checkins/gowalla_private', :access_token => 'access_token' do
+            checkins = GSGraph::Page.new('gowalla', :access_token => 'access_token').checkins
+            checkins.first.should == GSGraph::Checkin.new(
+              '696876187499',
+              :access_token => 'access_token',
+              :from => {
+                :id => '12820552',
+                :name => 'Roger Pincombe'
+              },
+              :tags => {
+                :data => [{
+                  :id => '4810308',
+                  :name => 'Mattt Thompson'
+                }]
+              },
+              :message => 'Checking out Austin, TX',
+              :place => {
+                :id => '120454134658381',
+                :name => 'Gowalla HQ',
+                :location => {
+                  :latitude => 30.26876,
+                  :longitude => -97.74962
+                }
+              },
+              :application => {
+                :id => '6628568379',
+                :name => 'Facebook for iPhone'
+              },
+              :created_time => '2010-09-08T00:09:25+0000'
+            )
+            checkins.each do |checkin|
+              checkin.should be_instance_of(GSGraph::Checkin)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#checkin!' do
+    it 'should POST :user_id/checkins' do
+      mock_graph :post, 'me/checkins', 'users/checkins/posted' do
+        checkin = GSGraph::User.me('token').checkin!(
+          :place => 'place_id',
+          :coordinates => {
+            :latitude => 30.26876,
+            :longitude => -97.74962
+          }.to_json
+        )
+        checkin.identifier.should == '10150090286117277'
+        checkin.place.should == GSGraph::Place.new('place_id')
+      end
+    end
+
+    context 'when tags are given' do
+      it 'should allow single tag' do
+        mock_graph :post, 'me/checkins', 'users/checkins/posted' do
+          checkin = GSGraph::User.me('token').checkin!(
+            :place => 'place_id',
+            :coordinates => {
+              :latitude => 30.26876,
+              :longitude => -97.74962
+            }.to_json,
+            :tags => 'friend_1'
+          )
+          checkin.tags.should == [GSGraph::User.new('friend_1')]
+        end
+      end
+
+      it 'should allow multiple tags' do
+        mock_graph :post, 'me/checkins', 'users/checkins/posted' do
+          checkin = GSGraph::User.me('token').checkin!(
+            :place => 'place_id',
+            :coordinates => {
+              :latitude => 30.26876,
+              :longitude => -97.74962
+            }.to_json,
+            :tags => ['friend_1', 'friend_2']
+          )
+          checkin.tags.should == [GSGraph::User.new('friend_1'), GSGraph::User.new('friend_2')]
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/comments_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Comments, '#comments' do
+  context 'when included by GSGraph::Post' do
+    let :post do
+      mock_graph :get, 'no_comments', 'posts/no_comments' do
+        GSGraph::Post.new('no_comments').fetch
+      end
+    end
+
+    describe 'cached comments' do
+      context 'when cached' do
+        it 'should use cache' do
+          lambda do
+            post.comments
+          end.should_not request_to "#{post.identifier}/comments"
+        end
+
+        context 'when options are specified' do
+          it 'should not use cache' do
+            lambda do
+              post.comments(:no_cache => true)
+            end.should request_to "#{post.identifier}/comments?no_cache=true"
+          end
+        end
+      end
+
+      context 'otherwise' do
+        let(:post) { GSGraph::Post.new(12345, :access_token => 'access_token') }
+
+        it 'should not use cache' do
+          lambda do
+            post.comments
+          end.should request_to '12345/comments?access_token=access_token'
+        end
+      end
+    end
+  end
+end
+
+describe GSGraph::Connections::Comments, '#comment!' do
+  context 'when included by GSGraph::Post' do
+    context 'when no access_token given' do
+      it 'should raise GSGraph::Exception' do
+        mock_graph :post, '12345/comments', 'posts/comments/post_without_access_token', :status => [500, 'Internal Server Error'] do
+          lambda do
+            GSGraph::Post.new('12345').comment!(:message => 'hello')
+          end.should raise_exception(GSGraph::Exception)
+        end
+      end
+    end
+
+    context 'when invalid access_token is given' do
+      it 'should raise GSGraph::Exception' do
+        mock_graph :post, '12345/comments', 'posts/comments/post_with_invalid_access_token', :status => [500, 'Internal Server Error'] do
+          lambda do
+            GSGraph::Post.new('12345', :access_token => 'invalid').comment!(:message => 'hello')
+          end.should raise_exception(GSGraph::Exception)
+        end
+      end
+    end
+
+    context 'when valid access_token is given' do
+      it 'should return generated comment' do
+        mock_graph :post, '12345/comments', 'posts/comments/post_with_valid_access_token' do
+          comment = GSGraph::Post.new('12345', :access_token => 'valid').comment!(:message => 'hello')
+          comment.identifier.should == '117513961602338_119401698085884_535271'
+          comment.access_token.should == 'valid'
+          comment.message.should == 'hello'
+          comment.access_token.should == 'valid'
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/conversations_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Conversations do
+  describe '#conversations' do
+    let(:page) do
+      GSGraph::Page.new('page_id', :access_token => 'page_token')
+    end
+
+    it 'should return an Array of GSGraph::Thread' do
+      mock_graph :get, 'page_id/conversations', 'pages/conversations/list', :access_token => 'page_token' do
+        conversations = page.conversations
+        conversations.should be_instance_of GSGraph::Connection
+        conversations.each do |conversation|
+          conversation.should be_instance_of GSGraph::Thread
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/declined_spec.rb

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

data/spec/gs_graph/connections/docs_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Docs do
+  describe '#docs' do
+    it 'should return docs as GSGraph::Doc' do
+      mock_graph :get, 'my_group/docs', 'groups/docs/private', :access_token => 'access_token' do
+        docs = GSGraph::Group.new('my_group', :access_token => 'access_token').docs
+        docs.each do |doc|
+          doc.should be_instance_of(GSGraph::Doc)
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/events_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Events, '#events' 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/events', 'users/events/matake_public', :status => [401, 'Unauthorized'] do
+          lambda do
+            GSGraph::User.new('matake').events
+          end.should raise_exception(GSGraph::Unauthorized)
+        end
+      end
+    end
+
+    context 'when access_token is given' do
+      it 'should return events as GSGraph::Event' do
+        mock_graph :get, 'matake/events', 'users/events/matake_private', :access_token => 'access_token' do
+          events = GSGraph::User.new('matake', :access_token => 'access_token').events
+          events.first.should == GSGraph::Event.new(
+            '116600818359630',
+            :access_token => 'access_token',
+            :name => 'The Loyal We @ Rainy Day Bookstore and Cafe',
+            :start_time => '2010-04-29T01:30:00+0000',
+            :end_time => '2010-04-29T04:30:00+0000',
+            :location => 'Nishi Azabu'
+          )
+          events.each do |event|
+            event.should be_instance_of(GSGraph::Event)
+          end
+        end
+      end
+    end
+  end
+end
+
+describe GSGraph::Connections::Events, '#events!' do
+  context 'when included by GSGraph::User' do
+    it 'should return generated note' do
+      mock_graph :post, 'matake/events', 'users/events/post_with_valid_access_token' do
+        event = GSGraph::User.new('matake', :access_token => 'valid').event!(
+          :name => 'GSGraph test event',
+          :start_time => Time.utc(2010, 5, 11, 10, 0, 0).to_i,
+          :end_time   => Time.utc(2010, 5, 11, 12, 0, 0).to_i
+        )
+        event.name.should == 'GSGraph test event'
+        event.access_token.should == 'valid'
+        event.start_time.should == Time.utc(2010, 5, 11, 10, 0, 0)
+        event.end_time.should == Time.utc(2010, 5, 11, 12, 0, 0)
+      end
+    end
+  end
+end