gs_graph 2.6.5

data/spec/gs_graph/test_user_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe GSGraph::TestUser, '.new' do
+
+  it 'should setup all supported attributes' do
+    attributes = {
+      :id => 12345,
+      :access_token => 'access_token',
+      :name => 'nov',
+      :login_url => 'https://www.gamestamper.com/login/test-user/12345',
+      :email => 'test1@client.example.com',
+      :password => 'password'
+    }
+    test_user = GSGraph::TestUser.new(attributes.delete(:id), attributes)
+    test_user.login_url.should == 'https://www.gamestamper.com/login/test-user/12345'
+    test_user.name.should == 'nov'
+    test_user.email.should == 'test1@client.example.com'
+    test_user.password.should == 'password'
+  end
+
+end
+
+describe GSGraph::TestUser, '.friend!' do
+
+  before do
+    @u1 = GSGraph::TestUser.new(111, :access_token => 'token1')
+    @u2 = GSGraph::TestUser.new(222, :access_token => 'token2')
+  end
+
+  it 'should POST twice' do
+    mock_graph :post, '111/friends/222', 'true', :access_token => 'token1' do
+      mock_graph :post, '222/friends/111', 'true', :access_token => 'token2' do
+        @u1.friend! @u2
+      end
+    end
+  end
+
+end
+
+describe GSGraph::TestUser, '.destroy' do
+  before do
+    @user = GSGraph::TestUser.new(111, :access_token => 'access_token')
+  end
+
+  it 'should DELETE /user_id' do
+    mock_graph :delete, '111', 'true', :access_token => 'access_token' do
+      @user.destroy
+    end
+  end
+end

data/spec/gs_graph/thread_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe GSGraph::Thread, '.new' do
+  it 'should setup all supported attributes' do
+    attributes = {
+      :id => "12345",
+      :snippet => 'test message',
+      :message_count => 2,
+      :unread_count => 1,
+      :updated_time => "2011-02-04T15:11:05+0000",
+      :tags => {
+        :data => [{
+          :name => "inbox"
+        }, {
+          :name => "source:web"
+        }]
+      },
+      :participants => {
+        :data => [{
+          :name => "Nov Matake",
+          :email => "xyz@gamestamper.com",
+          :id => "579612276"
+        }, {
+          :name => "Nov Matake",
+          :email => "abc@gamestamper.com",
+          :id => "1575327134"
+        }]
+      },
+      :senders => {
+        :data => [{
+          :name => "Nov Matake",
+          :email => "abc@gamestamper.com",
+          :id => "1575327134"
+        }]
+      },
+      :messages => {
+        :data => [{
+          :id => "m_25aaa73097e54594addb418c7bfbd05c",
+          :subject => "test",
+          :created_time => "2011-02-04T15:11:05+0000",
+          :tags => {
+            :data => [{
+              :name => "inbox"
+            }, {
+              :name => "source:web"
+            }]
+          },
+          :from => {
+            :name => "Nov Matake",
+            :email => "abc@gamestamper.com",
+            :id => "1575327134"
+          },
+          :to => {
+            :data => [{
+              :name => "Nov Matake",
+              :email => "xyz@gamestamper.com",
+              :id => "579612276"
+            }, {
+              :name => "Nov Matake",
+              :email => "abc@gamestamper.com",
+              :id => "1575327134"
+            }]
+          },
+          :message => "test"
+        }],
+        :paging => {
+          :previous => "https://graph.gamestamper.com/?access_token=access_token",
+          :next => "https://graph.gamestamper.com/?access_token=access_token"
+        }
+      }
+    }
+    thread = GSGraph::Thread.new(attributes.delete(:id), attributes)
+    thread.identifier.should == '12345'
+    thread.snippet.should == 'test message'
+    thread.message_count.should == 2
+    thread.unread_count.should == 1
+    thread.updated_time.should == Time.parse('2011-02-04T15:11:05+0000')
+    thread.tags.should == [
+      GSGraph::Tag.new(:name => 'inbox'),
+      GSGraph::Tag.new(:name => 'source:web')
+    ]
+    thread.senders.should == [
+      GSGraph::User.new('1575327134', :name => 'Nov Matake', :email => 'abc@gamestamper.com')
+    ]
+  end
+end

data/spec/gs_graph/user_achievement_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe GSGraph::UserAchievement do
+  subject { achievement }
+  let(:achievement) { GSGraph::UserAchievement.new(attributes[:id], attributes) }
+  let(:attributes) do
+    {
+      :id => "10150351898227277",
+      :from => {
+        :id => "10150351898227277",
+        :name => "Nov Matake"
+      },
+      :start_time => "2011-09-27T14:18:33+0000",
+      :end_time => "2011-09-27T14:18:33+0000",
+      :publish_time => "2011-09-27T14:18:33+0000",
+      :application => {
+        :id => "134145643294322",
+        :name => "gem sample"
+      },
+      :achievement => {
+        :id => "10150310611431721",
+        :url => "http:\/\/fbgraphsample.heroku.com\/achievements\/1",
+        :type => "game.achievement",
+        :title => "1st Achievement"
+      },
+      :likes => {
+        :count => 0
+      },
+      :comments => {
+        :count => 0
+      }
+    }
+  end
+
+  its(:from) { should be_a GSGraph::User }
+  its(:achievement) { should be_a GSGraph::Achievement }
+  its(:application) { should be_a GSGraph::Application }
+  its(:created_time) { should == Time.parse(attributes[:publish_time]).utc }
+
+  describe '#destroy' do
+    it 'should call DELETE /:app_id/achievements' do
+      expect { achievement.destroy }.to request_to('10150351898227277/achievements', :delete)
+    end
+
+    it 'should delete achievement' do
+      mock_graph :delete, '10150351898227277/achievements', 'true', :access_token => 'app_token', :params => {
+        :achievement => achievement.achievement.url
+      } do
+        achievement.destroy(:access_token => 'app_token').should be_true
+      end
+    end
+  end
+end

data/spec/gs_graph/user_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe GSGraph::User do
+  describe '.new' do
+    it 'should setup all supported attributes' do
+      attributes = {
+        :id => '12345',
+        :address => {
+          :city => "Kawasaki",
+          :state => "Kanagawa",
+          :country => "Japan"
+        },
+        :mobile_phone => '810000000000',
+        :installed => true
+      }
+      user = GSGraph::User.new(attributes.delete(:id), attributes)
+      user.address.should == GSGraph::Venue.new(attributes[:address])
+      user.mobile_phone.should == '810000000000'
+      user.installed.should be_true
+    end
+
+    it 'should support year-hidden birthday' do
+      user = GSGraph::User.new(12345, :birthday => '12/13')
+      user.birthday.year.should  == 0
+      user.birthday.month.should == 12
+      user.birthday.day.should   == 13
+    end
+
+    it 'should support non-default fields' do
+      mock_graph :get, 'me', 'users/with_non_default_fields', :access_token => 'access_token', :params => {
+        :fields => 'devices, video_upload_limits, age_range, currency'
+      } do
+        me = GSGraph::User.me('access_token').fetch(:fields => 'devices, video_upload_limits, age_range, currency')
+
+        # devices
+        me.devices.should be_instance_of Array
+        me.devices.each do |device|
+          device.should be_instance_of GSGraph::Device
+        end
+        me.devices.should == [GSGraph::Device.new(:os => 'iOS', :hardware => 'iPhone')]
+
+        # video_upload_limits
+        me.video_upload_limits.should be_instance_of ActiveSupport::HashWithIndifferentAccess
+        me.video_upload_limits.should == {'length' => 1200, 'size' => 1073741824}
+
+        # age_range
+        me.age_range.should be_instance_of GSGraph::AgeRange
+        me.age_range.should == Range.new(21, GSGraph::AgeRange::DEFAULT_MAX_AGE)
+
+        # currency
+        me.currency.should be_instance_of ActiveSupport::HashWithIndifferentAccess
+        me.currency.should == {
+          'user_currency' => 'JPY',
+          'currency_exchange' => 0.10846341,
+          'currency_exchange_inverse' => 9.2196990672,
+          'currency_offset' => 1
+        }
+      end
+    end
+  end
+
+  describe '.me' do
+    it 'should return GSGraph::User instance with access_token' do
+      GSGraph::User.me('access_token').should == GSGraph::User.new('me', :access_token => 'access_token')
+    end
+  end
+
+  describe '.fetch' do
+    context 'with me context' do
+
+      context 'when no access_token given' do
+        it 'should raise GSGraph::Unauthorized' do
+          mock_graph :get, 'me', 'users/me_public', :status => [401, 'Unauthorized'] do
+            lambda do
+              GSGraph::User.fetch('me')
+            end.should raise_exception(GSGraph::Unauthorized)
+          end
+        end
+      end
+
+      context 'when access_token given' do
+        it 'should get current user profile' do
+          mock_graph :get, 'me', 'users/me_private', :access_token => 'access_token' do
+            user = GSGraph::User.me('access_token').fetch
+            user.interested_in.should       == ['female']
+            user.relationship_status.should == 'Married'
+            user.website.should             == 'http://matake.jp'
+            user.religion.should            be_nil
+            user.political.should           be_nil
+            user.timezone.should            == 9
+            user.verified.should            be_true
+          end
+        end
+      end
+
+    end
+
+    context 'when no access_token given' do
+      it 'should get only public profile' do
+        mock_graph :get, 'arjun', 'users/arjun_public' do
+          user = GSGraph::User.fetch('arjun')
+          user.name.should       == 'Arjun Banker'
+          user.first_name.should == 'Arjun'
+          user.last_name.should  == 'Banker'
+          user.identifier.should == '7901103'
+          user.link.should       == 'http://www.gamestamper.com/Arjun'
+          user.location.should   == GSGraph::Page.new(114952118516947, :name => 'San Francisco, California')
+          user.gender.should     == 'male'
+        end
+      end
+    end
+
+    context 'when access_token given' do
+      it 'should get public + private profile' do
+        mock_graph :get, 'arjun', 'users/arjun_private', :access_token => 'access_token' do
+          user = GSGraph::User.fetch('arjun', :access_token => 'access_token')
+
+          # public
+          user.name.should       == 'Arjun Banker'
+          user.first_name.should == 'Arjun'
+          user.last_name.should  == 'Banker'
+          user.identifier.should == '7901103'
+          user.link.should       == 'http://www.gamestamper.com/Arjun'
+          user.location.should   == GSGraph::Page.new(114952118516947, :name => 'San Francisco, California')
+          user.gender.should     == 'male'
+
+          # private
+          user.about.should    == 'daydrea'
+          user.birthday.should == Date.strptime("04/15/1984", "%m/%d/%Y")
+          user.work.should     == [
+            GSGraph::Work.new({
+              :employer   => {:name => 'Facebook', :id => 20531316728},
+              :position   => {:name => 'Software Engineer', :id => 107879555911138},
+              :location   => {:name => 'Palo Alto, California', :id => 104022926303756},
+              :start_date => '2007-11'
+            }),
+            GSGraph::Work.new({
+              :employer   => {:name => 'Zillow', :id => 113816405300191},
+              :position   => {:name => 'Business Intelligence Analyst', :id => 105918922782444},
+              :start_date => '2006-03',
+              :end_date   => '2007-10'
+            }),
+            GSGraph::Work.new({
+              :employer   => {:name => 'Microsoft', :id => 20528438720},
+              :position   => {:name => 'SDET', :id => 110006949022640},
+              :start_date => '2004-08',
+              :end_date   => '2006-03'
+            }),
+            GSGraph::Work.new({
+              :employer   => {:name => 'Dell', :id => 7706457055},
+              :position   => {:name => 'Programmer Analyst', :id => 110344568993267},
+              :start_date => '2003-06',
+              :end_date   => '2004-07'
+            })
+          ]
+          user.education.should == [
+            GSGraph::Education.new({
+              :school => {:name => 'Texas Academy Of Math And Science', :id => 107922345906866},
+              :year   => {:name => '2001', :id => 102241906483610}
+            }),
+            GSGraph::Education.new({
+              :school => {:name => 'The University of Texas at Austin', :id => 24147741537},
+              :year   => {:name => '2003', :id => 108077232558120},
+              :concentration => [
+                {:name => 'Computer Science', :id => 116831821660155}
+              ]
+            })
+          ]
+          user.email.should               == nil
+          user.website.should             == nil
+          user.hometown.should            == GSGraph::Page.new(109533479072558, :name => 'Minnetonka, Minnesota')
+          user.interested_in.should       == ['female']
+          user.relationship_status.should == 'In a Relationship'
+          user.religion.should            == 'zorp'
+          user.political.should           == 'Liberal'
+          user.verified.should            be_nil
+          # What's this?
+          # user.significant_other
+          user.timezone.should            be_nil
+          user.updated_time.should        == Time.parse('2010-05-29T04:29:23+0000')
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/venue_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe GSGraph::Venue, '.new' do
+
+  it 'should setup all supported attributes' do
+    attributes = {
+      :street => "409 Colorado St.",
+      :city => "Austin",
+      :state => "Texas",
+      :country => "United States",
+      :latitude => 30.2669,
+      :longitude => -97.7428
+    }
+    venue = GSGraph::Venue.new(attributes)
+    venue.street.should == "409 Colorado St."
+    venue.city.should == "Austin"
+    venue.state.should == "Texas"
+    venue.country.should == "United States"
+    venue.latitude.should == 30.2669
+    venue.longitude.should == -97.7428
+  end
+
+end

data/spec/gs_graph/video_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe GSGraph::Video, '.new' do
+
+  it 'should setup all supported attributes' do
+    mock_graph :get, 'video', 'videos/private', :access_token => 'access_token' do
+      video = GSGraph::Video.new('video', :access_token => 'access_token').fetch
+      video.from.should be_a GSGraph::User
+      video.tags.should be_a Array
+      video.tags.each do |tag|
+        tag.should be_a GSGraph::Tag
+      end
+      [:name, :description, :embed_html, :icon, :source].each do |attribute|
+        video.send(attribute).should be_a String
+      end
+      [:created_time, :updated_time].each do |attribute|
+        video.send(attribute).should be_a Time
+      end
+    end
+  end
+
+  it 'should support page as from' do
+    page_video = GSGraph::Video.new('12345', :from => {
+      :id => '23456',
+      :name => 'Smart.fm',
+      :category => 'Web Site'
+    })
+    page_video.from.should == GSGraph::Page.new('23456', :name => 'Smart.fm', :category => 'Web Site')
+  end
+
+end

data/spec/gs_graph/work_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe GSGraph::Work, '.new' do
+
+  it 'should setup all supported attributes' do
+    attributes = {
+      :employer => {
+        :id => 107722015925937,
+        :name => "Drecom Co., Ltd."
+      },
+      :location => {
+        :id => 111736052177472,
+        :name => "Tokyo, Tokyo"
+      },
+      :position => {
+        :id => 111091815582753,
+        :name => "Web Engineer"
+      },
+      :projects => [{
+        :id   => 184246058253896,
+        :name => "Drecom Blog",
+        :with => [{
+          :id   => 1064067203,
+          :name => "Takanori Ishikawa"
+        }],
+        :start_date => "2008-04",
+        :end_date   => "2008-09"
+      }],
+      :start_date => "2007-04",
+      :end_date   => "2008-09"
+    }
+    work = GSGraph::Work.new(attributes)
+    work.employer.should == GSGraph::Page.new(
+      107722015925937,
+      :name => "Drecom Co., Ltd."
+    )
+    work.location.should == GSGraph::Page.new(
+      111736052177472,
+      :name => "Tokyo, Tokyo"
+    )
+    work.position.should == GSGraph::Page.new(
+      111091815582753,
+      :name => "Web Engineer"
+    )
+    work.projects.should == [GSGraph::Project.new(
+      184246058253896,
+      :name => "Drecom Blog",
+      :with => [{
+        :id   => 1064067203,
+        :name => "Takanori Ishikawa"
+      }],
+      :start_date => "2008-04",
+      :end_date   => "2008-09"
+    )]
+    work.start_date.should == Date.new(2007, 4)
+    work.end_date.should   == Date.new(2008, 9)
+  end
+
+  it 'should ignore 0000-00 style date' do
+    attributes = {
+      :employer => {
+        :id => 105612642807396,
+        :name => "Cerego Japan Inc."
+      },
+      :start_date => "0000-00",
+      :end_date   => "0000-00"
+    }
+    work = GSGraph::Work.new(attributes)
+    work.start_date.should be_nil
+    work.end_date.should be_nil
+  end
+
+  it 'should treat 2010-00 date ' do
+    attributes = {
+      :employer => {
+        :id => 105612642807396,
+        :name => "Cerego Japan Inc."
+      },
+      :start_date => "2008-00",
+      :end_date   => "2010-00"
+    }
+    work = GSGraph::Work.new(attributes)
+    work.start_date.should == Date.new(2008, 1)
+    work.end_date.should ==  Date.new(2010, 1)
+  end
+
+  it 'should treat 2010 date ' do
+    attributes = {
+      :employer => {
+        :id => 105612642807396,
+        :name => "Cerego Japan Inc."
+      },
+      :start_date => "2008",
+      :end_date   => "2010"
+    }
+    work = GSGraph::Work.new(attributes)
+    work.start_date.should == Date.new(2008)
+    work.end_date.should ==  Date.new(2010)
+  end
+
+end