gs_graph 2.6.5

data/spec/gs_graph/qeustion_option_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe GSGraph::QuestionOption do
+
+  describe '.new' do
+    it 'should setup all supported attributes' do
+      attributes = {
+        :id => '12345',
+        :from => {
+          :id => '23456',
+          :name => 'Mahmoud Khaled'
+        },
+        :name => 'option 1',
+        :votes => 5,
+        :object => {:name => "Ruby programming language",
+          :category => "Interest",
+          :id => "109932262369283"
+        },
+        :created_time => '2009-12-29T15:24:50+0000'
+      }
+      question = GSGraph::QuestionOption.new(attributes.delete(:id), attributes)
+      question.identifier.should        == '12345'
+      question.from.should              == GSGraph::User.new('23456', :name => 'Mahmoud Khaled')
+      question.name.should              == 'option 1'
+      question.vote_count.should        == 5
+      question.object.should            be_instance_of(GSGraph::Page)
+      question.object.name.should       == "Ruby programming language"
+      question.object.category.should   == "Interest"
+      question.object.identifier.should == "109932262369283"
+      question.created_time.should      == Time.parse('2009-12-29T15:24:50+0000')
+    end
+
+  end
+
+end

data/spec/gs_graph/query_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe GSGraph::Query do
+  let(:raw_query) { 'SELECT name FROM user WHERE uid = me()' }
+
+  describe '.new' do
+    let(:query) { GSGraph::Query.new(raw_query, 'access_token') }
+
+    it 'should setup query and access_token' do
+      query.query.should == raw_query
+      query.access_token.should == 'access_token'
+    end
+  end
+
+  describe '.fetch' do
+    let(:query) { GSGraph::Query.new(raw_query) }
+
+    context 'when no access token given' do
+      it 'should return blank Array' do
+        mock_fql raw_query, 'query/user/without_token' do
+          response = query.fetch
+          response.should == []
+        end
+      end
+    end
+
+    context 'when invalid access token given' do
+      it 'should raise exception' do
+        mock_fql raw_query, 'query/user/with_invalid_token', :access_token => 'invalid', :status => [400, 'Bad Request'] do
+          lambda do
+            query.fetch('invalid')
+          end.should raise_error GSGraph::Exception
+        end
+      end
+    end
+
+    context 'when valid access token given' do
+      it 'should return an Collection of Hash' do
+        mock_fql raw_query, 'query/user/with_valid_token', :access_token => 'valid' do
+          response = query.fetch('valid')
+          response.should be_instance_of GSGraph::Collection
+          response.should == [{'name' => 'Nov Matake'}]
+        end
+      end
+    end
+
+    context 'when multiquery given' do
+      let(:raw_query) do
+        {
+          :query1 => 'SELECT name FROM user WHERE uid = me()',
+          :query2 => 'SELECT name FROM user WHERE uid = me()'
+        }
+      end
+
+      it 'should return an Hash of Array of Hash' do
+        mock_fql raw_query.to_json, 'query/user/multi_query', :access_token => 'valid' do
+          response = query.fetch('valid')
+          response.should be_instance_of ActiveSupport::HashWithIndifferentAccess
+          response.each do |key, value|
+            value.should be_instance_of Array
+            value.each do |result|
+              result.should be_instance_of ActiveSupport::HashWithIndifferentAccess
+            end
+          end
+          response.should == {
+            "query1" => [{"name" => "Nov Matake"}],
+            "query2" => [{"name" => "Nov Matake"}]
+          }
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/question_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe GSGraph::Question do
+
+  describe '.new' do
+    it 'should setup all supported attributes' do
+      attributes = {
+        :id => '12345',
+        :from => {
+          :id => '23456',
+          :name => 'Mahmoud Khaled'
+        },
+        :question => 'question 1',
+        :created_time => '2009-12-29T15:24:50+0000',
+        :updated_time => '2010-01-02T15:37:41+0000',
+        :options => {
+          :data => [
+            {
+              :id => "34567",
+              :from => {
+                :name => "Mahmoud Khaled",
+                :id => "23456"
+              },
+              :name => "option 1",
+              :votes => 2,
+              :created_time => "2011-11-07T19:49:51+0000"
+            },
+            {
+              :id => "34568",
+              :from => {
+                :name => "Mustafa Badawy",
+                :id => "23457"
+              },
+              :name => "option 2",
+              :votes => 0,
+              :created_time => "2011-11-07T19:49:48+0000"
+            }
+          ]
+        } 
+      }
+      question = GSGraph::Question.new(attributes.delete(:id), attributes)
+      question.identifier.should == '12345'
+      question.from.should       == GSGraph::User.new('23456', :name => 'Mahmoud Khaled')
+      question.question.should   == 'question 1'
+      question.created_time.should == Time.parse('2009-12-29T15:24:50+0000')
+      question.updated_time.should == Time.parse('2010-01-02T15:37:41+0000')
+      question.question_options.should == [
+        GSGraph::QuestionOption.new(
+          '34567',
+          :from => {
+            :id => '23456',
+            :name => 'Mahmoud Khaled',
+          },
+          :name => "option 1",
+          :votes => 2,
+          :created_time => "2011-11-07T19:49:51+0000"
+        ),
+        GSGraph::QuestionOption.new(
+          '34568',
+          :from => {
+            :id => '23457',
+            :name => 'Mustafa Badawy',
+          },
+          :name => "option 2",
+          :votes => 0,
+          :created_time => "2011-11-07T19:49:48+0000"
+        )
+      ]
+    end
+
+  end
+
+end

data/spec/gs_graph/reach_estimate_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe GSGraph::ReachEstimate, '.new' do
+  let(:attributes) {
+    {
+      :users => 5503300,
+      :bid_estimations => [
+        {
+          :location => 3,
+          :cpc_min => 27,
+          :cpc_median => 37,
+          :cpc_max => 48,
+          :cpm_min => 8,
+          :cpm_median => 11,
+          :cpm_max => 14
+        }
+      ],
+      :imp_estimates => []
+    }
+  }
+
+  let(:attributes_through_ad_group) {
+    {
+      :data => attributes
+    }
+  }
+  it 'should setup all supported attributes' do
+    estimate = GSGraph::ReachEstimate.new(attributes)
+    estimate.users.should == 5503300
+    estimate.cpc_min.should == 27
+    estimate.cpc_median.should == 37
+    estimate.cpc_max.should == 48
+    estimate.cpm_min.should == 8
+    estimate.cpm_median.should == 11
+    estimate.cpm_max.should == 14
+  end
+
+  it 'should setup all supported attributes through AdGroup' do
+    estimate = GSGraph::ReachEstimate.new(attributes_through_ad_group)
+    estimate.users.should == 5503300
+    estimate.cpc_min.should == 27
+    estimate.cpc_median.should == 37
+    estimate.cpc_max.should == 48
+    estimate.cpm_min.should == 8
+    estimate.cpm_median.should == 11
+    estimate.cpm_max.should == 14
+  end
+end

data/spec/gs_graph/searchable_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe GSGraph::Searchable do
+  describe '.search' do
+    context 'when included by GSGraph::Page' do
+      it 'should with type=page' do
+        lambda do
+          GSGraph::Searchable.search('GSGraph')
+        end.should request_to('search?q=GSGraph')
+      end
+    end
+  end
+
+  describe '#search' do
+    context 'when included by GSGraph::Page' do
+      it 'should with type=page' do
+        lambda do
+          GSGraph::Page.search('GSGraph')
+        end.should request_to('search?q=GSGraph&type=page')
+      end
+    end
+  end
+end
+
+describe GSGraph::Searchable::Result do
+  let :gs_graph do
+    mock_graph :get, 'search?q=fbgraph&type=page', 'pages/search_gs_graph' do
+      GSGraph::Page.search('fbgraph')
+    end
+  end
+  let :google_page2 do
+    mock_graph :get, 'search?limit=25&offset=25&q=google&type=page', 'pages/search_google' do
+      GSGraph::Page.search('google', :limit => 25, :offset => 25)
+    end
+  end
+
+  it 'should support pagination' do
+    gs_graph.next.should     == []
+    gs_graph.previous.should == []
+    lambda do
+      google_page2.next
+    end.should request_to('search?limit=25&offset=50&q=google&type=page')
+    lambda do
+      google_page2.previous
+    end.should request_to('search?limit=25&offset=0&q=google&type=page')
+  end
+end

data/spec/gs_graph/seriarization_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+class Klass1
+  include GSGraph::Serialization
+  attr_accessor :att1, :att2
+end
+
+class Klass2 < Klass1
+  def to_hash(options = {})
+    {:att1 => self.att1, :att2 => self.att2}
+  end
+end
+
+describe GSGraph::Serialization do
+  before do
+    @node1 = Klass1.new
+    @node2 = Klass2.new
+    @node1.att1 = "hello"
+    @node2.att1 = "hello"
+  end
+
+  it 'should require to_hash' do
+    lambda do
+      @node1.to_json
+    end.should raise_error(StandardError, 'Define Klass1#to_hash!')
+    @node2.to_hash == {:att1 => 'hello', :att2 => nil}
+    @node2.to_json == {:att1 => 'hello'}.to_json
+  end
+end

data/spec/gs_graph/status_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe GSGraph::Status, '.new' do
+
+  it 'should setup all supported attributes' do
+    attributes = {
+      :id => '12345',
+      :from => {
+        :id => '23456',
+        :name => 'nov matake'
+      },
+      :message => 'hello, how are you?',
+      :updated_time => '2010-01-02T15:37:41+0000'
+    }
+    status = GSGraph::Status.new(attributes.delete(:id), attributes)
+    status.identifier.should   == '12345'
+    status.from.should         == GSGraph::User.new('23456', :name => 'nov matake')
+    status.message.should      == 'hello, how are you?'
+    status.updated_time.should == Time.parse('2010-01-02T15:37:41+0000')
+  end
+
+  it 'should support page as from' do
+    page_status = GSGraph::Status.new('12345', :from => {
+      :id => '23456',
+      :name => 'Smart.fm',
+      :category => 'Web Site'
+    })
+    page_status.from.should == GSGraph::Page.new('23456', :name => 'Smart.fm', :category => 'Web Site')
+  end
+
+end

data/spec/gs_graph/subscription_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe GSGraph::Subscription, '.new' do
+  # TODO
+end

data/spec/gs_graph/tag_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe GSGraph::Tag, '.new' do
+
+  it 'should setup all supported attributes' do
+    attributes = {
+      :id => "7901103",
+      :name => "Arjun Banker",
+      :x => 32.5,
+      :y => 27.7778,
+      :created_time => "2010-04-22T08:24:26+0000"
+    }
+    tag = GSGraph::Tag.new(attributes)
+    tag.user.should == GSGraph::User.new('7901103', :name => "Arjun Banker")
+    tag.name.should == 'Arjun Banker'
+    tag.x.should == 32.5
+    tag.y.should == 27.7778
+    tag.created_time.should == Time.parse("2010-04-22T08:24:26+0000")
+  end
+
+  it 'should not setup user if id is blank' do
+    attributes = {
+      :id => "",
+      :name => "Arjun Banker",
+      :x => 32.5,
+      :y => 27.7778,
+      :created_time => "2010-04-22T08:24:26+0000"
+    }
+    tag = GSGraph::Tag.new(attributes)
+    tag.user.should be_nil
+    tag.name.should == 'Arjun Banker'
+  end
+
+end

data/spec/gs_graph/tagged_object_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe GSGraph::TaggedObject do
+  let :attributes do
+    MultiJson.load(json).with_indifferent_access
+  end
+  let :json do
+    <<-JSON
+      {
+        "id": "1575327134",
+        "name": "Jr Nov",
+        "offset": 43,
+        "length": 6
+      }
+    JSON
+  end
+
+  it 'should setup all supported attributes' do
+    tagged_object = GSGraph::TaggedObject.new attributes[:id], attributes
+    tagged_object.identifier.should == '1575327134'
+    tagged_object.name.should == 'Jr Nov'
+    tagged_object.offset.should == 43
+    tagged_object.length.should == 6
+  end
+
+  describe '#fetch' do
+    context 'when tagged object is an User' do
+      it 'should return User' do
+        mock_graph :get, 'object_id', 'users/arjun_public' do
+          object = GSGraph::TaggedObject.new('object_id').fetch
+          object.should be_instance_of GSGraph::User
+        end
+      end
+    end
+
+    context 'when tagged object is a Page' do
+      it 'should return Page' do
+        mock_graph :get, 'object_id', 'pages/platform_public' do
+          object = GSGraph::TaggedObject.new('object_id').fetch
+          object.should be_instance_of GSGraph::Page
+        end
+      end
+    end
+  end
+end

data/spec/gs_graph/targeting_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe GSGraph::Targeting, '.new' do
+  it 'should setup all supported attributes' do
+    attributes = {
+      :country => 'jp',
+      :city    => 'Tokyo',
+      :region  => 'Tokyo',
+      :locale  => 9
+    }
+    targeting = GSGraph::Targeting.new(attributes)
+    targeting.country.should == 'jp'
+    targeting.city.should    == 'Tokyo'
+    targeting.region.should  == 'Tokyo'
+    targeting.locale.should  == 9
+  end
+end
+
+describe GSGraph::Targeting, '.to_json' do
+  it 'should return JSON object' do
+    attributes = {
+      :country => 'jp',
+      :city    => 'Tokyo',
+      :locale  => 9,
+      :region  => 'Tokyo'
+    }
+    targeting = GSGraph::Targeting.new(attributes)
+    hash = MultiJson.load(targeting.to_json).with_indifferent_access
+    hash[:country].should == attributes[:country]
+    hash[:city].should    == attributes[:city]
+    hash[:locale].should  == attributes[:locale]
+    hash[:region].should  == attributes[:region]
+  end
+end