gs_graph 2.6.5

data/spec/gs_graph/connections/interests_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Interests, '#interests' do
+  it 'should return interests pages as GSGraph::Page' do
+    mock_graph :get, 'matake/interests', 'users/interests/matake_private', :access_token => 'access_token' do
+      pages = GSGraph::User.new('matake', :access_token => 'access_token').interests
+      pages.each do |page|
+        page.should be_instance_of(GSGraph::Page)
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/invited_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Invited do
+  let(:event) { GSGraph::Event.new('smartday', :access_token => 'access_token') }
+
+  describe '#invited' do
+    it 'should return invited users as GSGraph::User' do
+      mock_graph :get, 'smartday/invited', 'events/invited/smartday_private', :access_token => 'access_token' do
+        event.invited.each do |user|
+          user.should be_instance_of(GSGraph::User)
+        end
+      end
+    end
+  end
+
+  describe '#invited?' do
+    context 'when invited' do
+      it 'should return RSVP status' do
+        mock_graph :get, 'smartday/invited/1575327134', 'events/invited/not_replied', :access_token => 'access_token' do
+          event.invited?(
+            GSGraph::User.new('1575327134')
+          ).should == :not_replied
+        end
+      end
+    end
+
+    context 'otherwise' do
+      it 'should return false' do
+        mock_graph :get, 'smartday/invited/12345', 'empty', :access_token => 'access_token' do
+          event.invited?(
+            GSGraph::User.new('12345')
+          ).should be_false
+        end
+      end
+    end 
+  end
+
+  describe '#invite!' do
+    context 'when options[:users] option is given' do
+      it 'should use it' do
+        mock_graph :post, 'smartday/invited', 'true', :access_token => 'access_token', :params => {
+          :users => "uid1,uid2"
+        } do
+          event.invite!(:users => "uid1,uid2").should be_true
+        end
+      end
+    end
+
+    context 'otherwise' do
+      context 'when single user is given' do
+        it 'should invite him/her' do
+          mock_graph :post, 'smartday/invited', 'true', :access_token => 'access_token', :params => {
+            :users => "uid1"
+          } do
+            event.invite!(
+              GSGraph::User.new("uid1")
+            ).should be_true
+          end
+        end
+      end
+
+      context 'when an Array of users are given' do
+        it 'should invite all of them' do
+          mock_graph :post, 'smartday/invited', 'true', :access_token => 'access_token', :params => {
+            :users => "uid1,uid2"
+          } do
+            event.invite!(
+              GSGraph::User.new("uid1"),
+              GSGraph::User.new("uid2")
+            ).should be_true
+          end
+        end
+      end
+    end
+  end
+
+  describe '#uninvite!' do
+    it 'should return true' do
+      mock_graph :delete, 'smartday/invited/uid', 'true', :access_token => 'access_token' do
+        event.uninvite!(GSGraph::User.new("uid")).should be_true
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/likes_spec.rb

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe GSGraph::Connections::Likes do
+  describe '#likes' do
+    context 'when liked by a Page' do
+      it 'should handle the liker as a Page' do
+        mock_graph :get, 'post_id', 'posts/liked_by_page', :access_token => 'access_token' do
+          post = GSGraph::Post.new('post_id').fetch(:access_token => 'access_token')
+          post.likes.first.should be_instance_of GSGraph::Page
+        end
+      end
+    end
+
+    context 'when included by GSGraph::Post' do
+      let(:post) { GSGraph::Post.new('post_id', :access_token => 'access_token', :likes => {}) }
+
+      describe 'cached likes' do
+        context 'when cached' do
+          it 'should use cache' do
+            lambda do
+              post.likes
+            end.should_not request_to 'post_id/likes?access_token=access_token'
+          end
+
+          context 'when options are specified' do
+            it 'should not use cache' do
+              lambda do
+                post.likes(:no_cache => true)
+              end.should request_to 'post_id/likes?access_token=access_token&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.likes
+            end.should request_to '12345/likes?access_token=access_token'
+          end
+        end
+      end
+    end
+
+    context 'when included by GSGraph::Status' do
+      context 'when cached collection exists' do
+        before do
+          mock_graph :get, 'with_likes', 'statuses/with_likes', :access_token => 'access_token' do
+            @status = GSGraph::Status.new('with_likes').fetch(:access_token => 'access_token')
+          end
+        end
+
+        context 'when no options given' do
+          it 'should not access to Graph API' do
+            @status.likes.should == [GSGraph::User.new(
+              '604578140',
+              :access_token => 'access_token',
+              :name => 'K Hiromi'
+            )]
+            @status.likes.next.should == []
+            @status.likes.previous.should == []
+          end
+        end
+
+        context 'when any options given' do
+          it 'should access to Graph API' do
+            lambda do
+              @status.likes(:no_cache => true) # :no_cache has no meaning, just putting some value as options
+            end.should request_to('115838235152172/likes?access_token=access_token&no_cache=true')
+            lambda do
+              @status.likes(:limit => 10)
+            end.should request_to('115838235152172/likes?access_token=access_token&limit=10')
+          end
+
+          context 'when next/previous are obviously blank' do
+            it 'should not access to Graph API' do
+              @status.likes.next(:no_cache => true).should == []
+              @status.likes.previous(:no_cache => true).should == []
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#like!' 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/likes', 'posts/likes/post_without_access_token', :status => [500, 'Internal Server Error'] do
+            lambda do
+              GSGraph::Post.new('12345').like!
+            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/likes', 'posts/likes/post_with_invalid_access_token', :status => [500, 'Internal Server Error'] do
+            lambda do
+              GSGraph::Post.new('12345', :access_token => 'invalid').like!
+            end.should raise_exception(GSGraph::Exception)
+          end
+        end
+      end
+
+      context 'when valid access_token is given' do
+        it 'should return true' do
+          mock_graph :post, '12345/likes', 'posts/likes/post_with_valid_access_token' do
+            GSGraph::Post.new('12345', :access_token => 'valid').like!.should be_true
+          end
+        end
+      end
+    end
+  end
+
+  describe '#unlike!' do
+    it 'should DELETE /:object_id/likes' do
+      mock_graph :delete, '12345/likes', 'true', :access_token => 'valid' do
+        GSGraph::Post.new('12345', :access_token => 'valid').unlike!
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/links_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Links, '#links' do
+  context 'when included by GSGraph::User' do
+    it 'should return notes as GSGraph::Link' do
+      mock_graph :get, 'matake/links', 'users/links/matake_private', :access_token => 'access_token' do
+        links = GSGraph::User.new('matake', :access_token => 'access_token').links
+        links.each do |link|
+          link.should be_instance_of(GSGraph::Link)
+        end
+      end
+    end
+  end
+end
+
+describe GSGraph::Connections::Links, '#link!' do
+  context 'when included by GSGraph::User' do
+    it 'should return generated link' do
+      mock_graph :post, 'matake/links', 'users/links/post_with_valid_access_token' do
+        link = GSGraph::User.new('matake', :access_token => 'valid').link!(
+          :link => 'http://github.com/nov/gs_graph',
+          :message => 'A Ruby wrapper for Facebook Graph API.'
+        )
+        link.identifier.should == 120765121284251
+        link.link.should == 'http://github.com/nov/gs_graph'
+        link.message.should == 'A Ruby wrapper for Facebook Graph API.'
+        link.access_token.should == 'valid'
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/maybe_spec.rb

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

data/spec/gs_graph/connections/members_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Members do
+  let :member do
+    GSGraph::User.new('member_id')
+  end
+
+  context 'when included in GSGraph::Group' do
+    describe '#members' do
+      it 'should return members as GSGraph::User' do
+        mock_graph :get, 'emacs/members', 'groups/members/emacs_private', :access_token => 'access_token' do
+          users = GSGraph::Group.new('emacs', :access_token => 'access_token').members
+          users.each do |user|
+            user.should be_instance_of GSGraph::User
+          end
+        end
+      end
+    end
+
+    describe '#member!' do
+      it :NOT_SUPPORTED_YET
+    end
+
+    describe '#unmember!' do
+      it :NOT_SUPPORTED_YET
+    end
+  end
+
+  context 'when included in GSGraph::FriendList' do
+    describe '#members' do
+      it 'should return members as GSGraph::User' do
+        mock_graph :get, 'list_id/members', 'friend_lists/members/sample', :access_token => 'access_token' do
+          users = GSGraph::FriendList.new('list_id', :access_token => 'access_token').members
+          users.each do |user|
+            user.should be_instance_of GSGraph::User
+          end
+        end
+      end
+    end
+
+    describe '#member!' do
+      it 'should return true' do
+        mock_graph :post, 'list_id/members/member_id', 'true', :access_token => 'access_token' do
+          GSGraph::FriendList.new('list_id', :access_token => 'access_token').member!(member).should be_true
+        end
+      end
+    end
+
+    describe '#unmember!' do
+      it 'should return true' do
+        mock_graph :delete, 'list_id/members/member_id', 'true', :access_token => 'access_token' do
+          GSGraph::FriendList.new('list_id', :access_token => 'access_token').unmember!(member).should be_true
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/messages_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Messages do
+  describe '#messages' do
+    it 'should return threads as GSGraph::Message' do
+      mock_graph :get, '12345/messages', 'thread/messages/private', :params => {:no_cache => 'true'}, :access_token => 'access_token' do
+        messages = GSGraph::Thread.new(12345, :access_token => 'access_token').messages(:no_cache => true)
+        messages.each do |message|
+          message.should be_instance_of(GSGraph::Message)
+        end
+      end
+    end
+
+    describe 'cached messages' do
+      context 'when cached' do
+        let(:thread) { GSGraph::Thread.new(12345, :access_token => 'access_token', :messages => {}) }
+
+        it 'should use cache' do
+          lambda do
+            thread.messages
+          end.should_not request_to '12345/messages?access_token=access_token'
+        end
+
+        context 'when options are specified' do
+          it 'should not use cache' do
+            lambda do
+              thread.messages(:no_cache => true)
+            end.should request_to '12345/messages?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.messages
+          end.should request_to '12345/messages?access_token=access_token'
+        end
+      end
+    end
+  end
+
+  describe '#message!' do
+    let(:thread) { GSGraph::Thread.new(12345, :access_token => 'access_token') }
+
+    it 'should return GSGraph::Message' do
+      mock_graph :post, '12345/messages', 'thread/messages/created', :access_token => 'access_token', :params => {
+        :message => 'Hello'
+      } do
+        message = thread.message! 'Hello'
+        message.should be_instance_of GSGraph::Message
+        message.message.should == 'Hello'
+      end
+    end
+  end
+end

data/spec/gs_graph/connections/milestones_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe GSGraph::Connections::Milestones do
+  let(:page) do
+    GSGraph::Page.new('page_id', :access_token => 'page_token')
+  end
+
+  describe '#milestones' do
+    it 'should return an Array of GSGraph::Milestone' do
+      mock_graph :get, 'page_id/milestones', 'pages/milestones/list', :access_token => 'page_token' do
+        milestones = page.milestones
+        milestones.should be_instance_of GSGraph::Connection
+        milestones.each do |milestone|
+          milestone.should be_instance_of GSGraph::Milestone
+        end
+      end
+    end
+  end
+
+  describe '#milestone!' do
+    it 'should return generated milestone' do
+      started_at = 3.years.ago
+      mock_graph :post, 'page_id/milestones', 'pages/milestones/created', :access_token => 'page_token', :params => {
+        :title => 'Reached 1M users!',
+        :description => 'Finally we got 1M-th user!',
+        :start_time => started_at.to_s
+      } do
+        milestone = page.milestone!(
+          :title => 'Reached 1M users!',
+          :description => 'Finally we got 1M-th user!',
+          :start_time => started_at
+        )
+        milestone.should be_instance_of GSGraph::Milestone
+        milestone.title.should       == 'Reached 1M users!'
+        milestone.description.should == 'Finally we got 1M-th user!'
+        milestone.start_time.should  == started_at
+      end
+    end
+  end
+end