gs_graph 2.6.5

data/spec/gs_graph/education_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe GSGraph::Education, '.new' do
+
+  it 'should setup all supported attributes' do
+    attributes = {
+      :school => {
+        :id => 110149592341159,
+        :name => "\u540c\u5fd7\u793e\u5927\u5b66"
+      },
+      :degree => {
+        :id => 110616875633830,
+        :name => "Master of Engineering"
+      },
+      :year => {
+        :id => 104926492884272,
+        :name => "2007"
+      },
+      :concentration => [
+        {
+          :id => 112303688789448,
+          :name => "Engineering"
+        },
+        {
+          :id => 102358546472290,
+          :name => "Intelligent Information"
+        },
+        {
+          :id => 108311762535367,
+          :name => "Intelligent Systems Design Laboratory"
+        }
+      ]    }
+    education = GSGraph::Education.new(attributes)
+    education.school.should == GSGraph::Page.new(
+      110149592341159,
+      :name => "\u540c\u5fd7\u793e\u5927\u5b66"
+    )
+    education.degree.should == GSGraph::Page.new(
+      110616875633830,
+      :name => "Master of Engineering"
+    )
+    education.year.should == GSGraph::Page.new(
+      104926492884272,
+      :name => "2007"
+    )
+    education.concentration.should == [
+      GSGraph::Page.new(
+        112303688789448,
+        :name => "Engineering"
+      ),
+      GSGraph::Page.new(
+        102358546472290,
+        :name => "Intelligent Information"
+      ),
+      GSGraph::Page.new(
+        108311762535367,
+        :name => "Intelligent Systems Design Laboratory"
+      )
+    ]
+  end
+end

data/spec/gs_graph/event_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe GSGraph::Event do
+  let :attributes do
+    {
+      :id => '12345',
+      :owner => {
+        :id => '23456',
+        :name => 'nov matake'
+      },
+      :name => 'event 1',
+      :description => 'an event for gs_graph test',
+      :start_time => '2010-03-14T21:00:00+0000',
+      :end_time => '2010-03-15T00:30:00+0000',
+      :location => 'Smart.fm office',
+      :venue => {
+        :street => 'Sakuragaoka',
+        :city => 'Shibuya',
+        :state => 'Tokyo',
+        :zip => '150-0031',
+        :country => 'Japan',
+        :latitude => '35.685',
+        :longitude => '139.751'
+      },
+      :privacy => 'OPEN',
+      :updated_time => '2010-01-02T15:37:41+0000'
+    }
+  end
+  let(:event) { GSGraph::Event.new(attributes.delete(:id), attributes) }
+
+  describe '.new' do
+    it 'should setup all supported attributes' do
+      event.identifier.should   == '12345'
+      event.owner.should        == GSGraph::User.new('23456', :name => 'nov matake')
+      event.name.should         == 'event 1'
+      event.description.should  == 'an event for gs_graph test'
+      event.start_time.should   == Time.parse('2010-03-14T21:00:00+0000')
+      event.end_time.should     == Time.parse('2010-03-15T00:30:00+0000')
+      event.location.should     == 'Smart.fm office'
+      event.venue.should        == GSGraph::Venue.new(
+        :street => 'Sakuragaoka',
+        :city => 'Shibuya',
+        :state => 'Tokyo',
+        :zip => '150-0031',
+        :country => 'Japan',
+        :latitude => '35.685',
+        :longitude => '139.751'
+      )
+      event.privacy.should      == 'OPEN'
+      event.updated_time.should == Time.parse('2010-01-02T15:37:41+0000')
+    end
+  end
+
+  describe '#update' do
+    it 'should update existing event' do
+      lambda do
+        event.update(:location => 'Kyoto', :access_token => 'access_token')
+      end.should request_to('12345', :post)
+    end
+  end
+
+  context 'when venue is a page' do
+    it 'should use GSGraph::Page instead of GSGraph::Venue' do
+      mock_graph :get, 'event_id', 'events/with_venue_as_page', :access_token => 'access_token' do
+        event = GSGraph::Event.fetch('event_id', :access_token => 'access_token')
+        event.venue.should be_instance_of GSGraph::Page
+      end
+    end
+  end
+end

data/spec/gs_graph/exception_spec.rb

@@ -0,0 +1,310 @@
+require 'spec_helper'
+
+describe GSGraph::Exception do
+  it 'should properly set its message for inspect' do
+    err = GSGraph::Exception.new(400, 'This is the error message')
+    err.inspect.should == '#<GSGraph::Exception: This is the error message>'
+  end
+
+  context 'when response body is given' do
+    it 'should setup message and type from error' do
+      err = GSGraph::Exception.new(400, 'This is the original message', {
+        :error => {
+          :type => 'SomeError',
+          :message => 'This is the error message'
+        }
+      }.to_json)
+      err.code.should == 400
+      err.type.should == 'SomeError'
+      err.message.should == 'This is the error message'
+    end
+  end
+
+  context 'when response body is not given' do
+    it 'should not have type' do
+      err = GSGraph::Exception.new(400, 'This is the original message')
+      err.code.should == 400
+      err.type.should be_nil
+      err.message.should == 'This is the original message'
+    end
+  end
+end
+
+describe GSGraph::BadRequest do
+  it 'should have 400 status code' do
+    err = GSGraph::BadRequest.new 'Bad Request'
+    err.code.should == 400
+  end
+end
+
+describe GSGraph::Unauthorized do
+  it 'should have 401 status code' do
+    err = GSGraph::Unauthorized.new 'Unauthorized'
+    err.code.should == 401
+  end
+end
+
+describe GSGraph::NotFound do
+  it 'should have 404 status code' do
+    err = GSGraph::NotFound.new 'Not Found'
+    err.code.should == 404
+  end
+end
+
+describe GSGraph::Exception, ".handle_httpclient_error" do
+  context "when WWW-Authenticate header is present" do
+    context "with an expired access token" do
+      let(:parsed_response) do
+        {
+          :error => {
+            :message => "Error validating access token: The session has been invalidated because the user has changed the password.",
+            :type => "OAuthException"
+          }
+        }
+      end
+      let(:headers) do
+        {
+          "WWW-Authenticate" => 'OAuth "Facebook Platform" "invalid_token" "Error validating access token: The session has been invalidated because the user has changed the password.'
+        }
+      end
+
+      it "should raise an InvalidSession exception" do
+        lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, headers)}.should raise_exception(GSGraph::InvalidSession)
+      end
+    end
+
+    context "with an invalid access token" do
+      let(:parsed_response) do
+        {
+          :error => {
+            :message => 'Invalid OAuth access token.',
+            :type => "OAuthException"
+          }
+        }
+      end
+      let(:headers) do
+        {
+          "WWW-Authenticate" => 'OAuth "Facebook Platform" "invalid_token" "Invalid OAuth access token."'
+        }
+      end
+
+      it "should raise an InvalidToken exception" do
+        lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, headers)}.should raise_exception(GSGraph::InvalidToken)
+      end
+
+      context "with a variant capitalization of the header" do
+        let(:headers) do
+          {
+            "Www-Authenticate" => 'OAuth "Facebook Platform" "invalid_token" "Invalid OAuth access token."'
+          }
+        end
+
+        it "should raise an InvalidToken exception" do
+          lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, headers)}.should raise_exception(GSGraph::InvalidToken)
+        end
+      end
+    end
+
+    context "with an invalid request" do
+      let(:parsed_response) do
+        {
+          :error => {
+            :message => '(#100) Must include the \"campaign_id\" index',
+            :type => "OAuthException"
+          }
+        }
+      end
+      let(:headers) do
+        {
+          "WWW-Authenticate" =>'OAuth "Facebook Platform" "invalid_request" "(#100) Must include the \"campaign_id\" index"'
+        }
+      end
+
+      it "should raise an InvalidRequest exception" do
+        lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, headers)}.should raise_exception(GSGraph::InvalidRequest)
+      end
+    end
+  end
+
+  context "without the WWW-Authenticate header" do
+    context "with an OAuthException" do
+      let(:parsed_response) do
+        {
+          :error => {
+            :message => 'Some kind of OAuthException',
+            :type => "OAuthException"
+          }
+        }
+      end
+
+      it "should raise an Unauthorized exception" do
+        lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::Unauthorized)
+      end
+    end
+
+    context "with an Exception" do
+      let(:parsed_response) do
+        {
+          :error => {
+            :message => 'Some kind of Exception',
+            :type => "Exception"
+          }
+        }
+      end
+
+      it "should raise a BadRequest exception" do
+        lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::BadRequest)
+      end
+
+      context "with an Ads API Exception" do
+        context "of Could not save creative" do
+          let(:parsed_response) do
+            {
+              :error => {
+                :message => 'Could not save creative',
+                :type => "Exception"
+              }
+            }
+          end
+
+          it "should raise a CreativeNotSaved exception" do
+            lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::CreativeNotSaved)
+          end
+        end
+
+        context "of QueryLockTimeout" do
+          let(:parsed_response) do
+            {
+              :error => {
+                :message => 'QueryLockTimeoutException',
+                :type => "Exception"
+              }
+            }
+          end
+
+          it "should raise a QueryLockTimeout exception" do
+            lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::QueryLockTimeout)
+          end
+        end
+
+        context "of Could not create targeting spec" do
+          let(:parsed_response) do
+            {
+              :error => {
+                :message => 'Could not create targeting spec',
+                :type => "Exception"
+              }
+            }
+          end
+
+          it "should raise a TargetingSpecNotSaved exception" do
+            lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::TargetingSpecNotSaved)
+          end
+        end
+
+        context "of Could not fetch adgroups" do
+          let(:parsed_response) do
+            {
+              :error => {
+                :message => 'Could not fetch adgroups',
+                :type => "Exception"
+              }
+            }
+          end
+
+          it "should raise a AdgroupFetchFailure exception" do
+            lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::AdgroupFetchFailure)
+          end
+        end
+
+        context "of Failed to open process" do
+          let(:parsed_response) do
+            {
+              :error => {
+                :message => 'Failed to open process',
+                :type => "Exception"
+              }
+            }
+          end
+
+          it "should raise a OpenProcessFailure exception" do
+            lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::OpenProcessFailure)
+          end
+        end
+
+        context "of Could not commit transaction" do
+          let(:parsed_response) do
+            {
+              :error => {
+                :message => 'Could not commit transaction',
+                :type => "Exception"
+              }
+            }
+          end
+
+          it "should raise a TransactionCommitFailure exception" do
+            lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::TransactionCommitFailure)
+          end
+        end
+
+        context "of QueryErrorException" do
+          let(:parsed_response) do
+            {
+              :error => {
+                :message => 'DB Error: QueryErrorException',
+                :type => "Exception"
+              }
+            }
+          end
+
+          it "should raise a QueryError exception" do
+            lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::QueryError)
+          end
+        end
+
+        context "of QueryConnectionException" do
+          let(:parsed_response) do
+            {
+              :error => {
+                :message => 'QueryConnectionException',
+                :type => "Exception"
+              }
+            }
+          end
+
+          it "should raise a QueryConnection exception" do
+            lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::QueryConnection)
+          end
+        end
+
+        context "of QueryDuplicateKeyException" do
+          let(:parsed_response) do
+            {
+              :error => {
+                :message => 'QueryDuplicateKeyException',
+                :type => "Exception"
+              }
+            }
+          end
+
+          it "should raise a QueryDuplicateKey exception" do
+            lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::QueryDuplicateKey)
+          end
+        end
+      end
+    end
+    context "with an Exception not containing the error field" do
+      let(:parsed_response) do
+        {
+          :error_code => 1,
+          :error_msg => "An unknown error occurred."
+        }
+      end
+
+      it "should raise an InternalServerError exception" do
+        lambda {GSGraph::Exception.handle_httpclient_error(parsed_response, {})}.should raise_exception(GSGraph::InternalServerError)
+      end
+
+    end
+  end
+end

data/spec/gs_graph/friend_list_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe GSGraph::FriendList do
+
+  it 'should setup all supported attributes' do
+    attributes = {
+      :id => '12345',
+      :name => 'My List'
+    }
+    video = GSGraph::FriendList.new(attributes.delete(:id), attributes)
+    video.identifier.should == '12345'
+    video.name.should       == 'My List'
+  end
+
+  describe 'destroy' do
+    it 'should return true' do
+      mock_graph :delete, 'list_id', 'true', :access_token => 'access_token' do
+        GSGraph::FriendList.new('list_id').destroy(:access_token => 'access_token').should be_true
+      end
+    end
+  end
+end