gnip_api 1.1.3 → 1.2.0

data/lib/gnip_api/response.rb

@@ -31,5 +31,26 @@ module GnipApi
       end
       return nil
     end
+
+    def check_for_errors!
+      if ok?
+        GnipApi.logger.info "#{request_method} request to #{request_uri} returned with status #{status} OK"
+        GnipApi.logger.debug "Headers -> #{headers.inspect}"
+        GnipApi.logger.debug "Body -> #{body.inspect}"
+        GnipApi.logger.debug "Request headers -> #{request.headers.inspect}"
+        GnipApi.logger.debug "Request payload -> #{request.payload.inspect}"
+      else
+        error_message = error_message
+        GnipApi.logger.error "#{request_method} request to #{request_uri} returned with status #{status} FAIL"
+        GnipApi.logger.debug "Headers -> #{headers.inspect}"
+        GnipApi.logger.debug "Body -> #{body.inspect}"
+        GnipApi.logger.debug "Request headers -> #{request.headers.inspect}"
+        GnipApi.logger.debug "Request payload -> #{request.payload.inspect}"
+        raise GnipApi::Errors::Adapter::GnipSoftwareError.new error_message if status == 503
+        raise GnipApi::Errors::Adapter::RateLimitError.new error_message if status == 429
+        raise GnipApi::Errors::Adapter::RequestError.new error_message
+      end
+    end
+
   end
 end

data/lib/gnip_api/search.rb

@@ -0,0 +1,108 @@
+# Gnip Search Full Archive API
+#
+# Retrive counts with a provided rule
+
+module GnipApi
+  class Search
+    attr_reader :adapter
+
+    def initialize params={}
+      @adapter = GnipApi::Adapter.new
+      @label = params[:label] || GnipApi.config.label
+    end
+
+    def activities options={}
+      required_options?(options)
+      payload = construct_activities_payload(options)
+      request = GnipApi::Request.new_post(activities_endpoint, payload)
+      data = adapter.post(request)
+      return parse_activities_response(data)
+    end
+
+    def counts options={}
+      required_options?(options)
+      payload = construct_counts_payload(options)
+      request = GnipApi::Request.new_post(count_endpoint, payload)
+      data = adapter.post(request)
+      return parse_counts_response(data)
+    end
+
+    private
+    def count_endpoint
+      GnipApi::Endpoints.search_counts(@label)
+    end
+
+    def activities_endpoint
+      GnipApi::Endpoints.search_activities(@label)
+    end
+
+    def required_options
+      [:rule]
+    end
+
+    def required_options? options
+      provided_options = required_options - options.keys
+      raise GnipApi::Errors::Search::MissingParameters.new(provided_options) if provided_options.any?
+    end
+
+    def parse_date date
+      return nil unless date
+      date.strftime('%Y%m%d%H%M')
+    end
+
+    def parse_counts_response data
+      parsed_data = GnipApi::JsonParser.new.parse(data)
+      result_set = parsed_data['results']
+      params = parsed_data['requestParameters']
+      result = {:results => [], :total_count => parsed_data['totalCount'], :next => parsed_data['next'], :request_parameters => {}}
+      result[:request_parameters][:bucket] = params['bucket'] if params['bucket']
+      result[:request_parameters][:from_date] = Time.parse("#{params['fromDate']}-0000") if params['fromDate']
+      result[:request_parameters][:to_date] = Time.parse("#{params['toDate']}-0000") if params['toDate']
+      result_set.each do |item|
+        result[:results] << {:time_period => Time.parse("#{item['timePeriod']}-0000"), :count => item['count']}
+      end
+      return result
+    end
+
+    def parse_activities_response data
+      parsed_data = GnipApi::JsonParser.new.parse(data)
+      result_set = parsed_data['results']
+      params = parsed_data['requestParameters']
+      result = {:results => [], :next => parsed_data['next'], :request_parameters => {}}
+      result[:request_parameters][:bucket] = params['bucket'] if params['bucket']
+      result[:request_parameters][:from_date] = Time.parse("#{params['fromDate']}-0000") if params['fromDate']
+      result[:request_parameters][:to_date] = Time.parse("#{params['toDate']}-0000") if params['toDate']
+      result[:request_parameters][:max_results] = params['maxResults'] if params['maxResult']
+      result_set.each do |item|
+        result[:results] << Gnip::Activity.new(item)
+      end
+      return result
+    end
+
+    def construct_counts_payload options
+      payload = {
+        :query => options[:rule].value,
+        :fromDate => parse_date(options[:from_date]),
+        :toDate => parse_date(options[:to_date]),
+        :bucket => options[:bucket],
+        :next => options[:next_token]
+      }
+      payload.delete_if{|k,v| v.nil?}
+      return payload.to_json
+    end
+
+    def construct_activities_payload options
+      payload = {
+        :query => options[:rule].value,
+        :fromDate => parse_date(options[:from_date]),
+        :toDate => parse_date(options[:to_date]),
+        :tag => options[:rule].tag,
+        :maxResults => options[:max_results],
+        :next => options[:next_token]
+      }
+      payload.delete_if{|k,v| v.nil?}
+      return payload.to_json
+    end
+  end
+end
+

data/lib/gnip_api/version.rb

@@ -1,3 +1,3 @@
 module GnipApi
-  VERSION = "1.1.3"
+  VERSION = "1.2.0"
 end

data/lib/gnip_api.rb

@@ -9,11 +9,11 @@ require "gnip_api/version"
 require "gnip_api/errors"
 require "gnip_api/configuration"
 require "gnip_api/endpoints"
-require "gnip_api/apis/power_track/stream"
-require "gnip_api/apis/power_track/rules"
-require "gnip_api/apis/power_track/buffer"
-require "gnip_api/apis/power_track/rule"
-require "gnip_api/apis/search"
+require "gnip_api/power_track/stream"
+require "gnip_api/power_track/rules"
+require "gnip_api/power_track/buffer"
+require "gnip_api/power_track/rule"
+require "gnip_api/search"
 require "gnip_api/gnip/message"
 require "gnip_api/gnip/system_message"
 require "gnip_api/gnip/twitter_compliance_message"
@@ -22,8 +22,6 @@ require "gnip_api/gnip/activity"
 require "gnip_api/gnip/gnip_data"
 require "gnip_api/gnip/url"
 require "gnip_api/adapter"
-require "gnip_api/adapters/base_adapter"
-require "gnip_api/adapters/httparty_adapter"
 require "gnip_api/response"
 require "gnip_api/request"
 require "gnip_api/json_parser"

data/spec/fixtures/rule_value_examples.json

@@ -0,0 +1,27 @@
+{
+  "consistent":
+  [
+    "value",
+    "(value)",
+    "value OR (value)",
+    "(value OR (value))",
+    " (value OR value)",
+    " (value) OR value ",
+    "\"value\"",
+    " \"value\"",
+    " \"value\" ",
+    "\"value's\"",
+    "\"(('()\"",
+    "'value'","'(()('"
+  ],
+  "inconsistent":
+  [
+    "value)",
+    "(value","value OR value)",
+    " (value",
+    " value)",
+    "\"value",
+    "'value",
+    ")value"
+  ]
+}

data/spec/gnip_api/adapter_spec.rb

@@ -14,95 +14,8 @@ describe GnipApi::Adapter do
     expect(Proc.new{GnipApi::Adapter.new}).to raise_error(GnipApi::Errors::MissingCredentials)
   end
 
-  it 'raises error if no adapter is selected' do
-    GnipApi.configure do |c|
-      c.user = 'somebody'
-      c.password = 'something'
-      c.account = 'lol'
-      c.adapter_class = nil
-    end
-    
-    expect(Proc.new{GnipApi::Adapter.new}).to raise_error(GnipApi::Errors::MissingAdapter)
-  end
-
   it 'does not raise error when credentials and adapter are present' do
     configure_gem
     expect(Proc.new{GnipApi::Adapter.new}).not_to raise_error
   end
-
-  it 'uses adapter selected' do
-    configure_gem
-    GnipApi.configuration.adapter_class = TestAdapter
-    expect(GnipApi::Adapter.new.adapter.class).to eq(TestAdapter)
-  end
-
-  describe '#get' do
-    before do
-      configure_gem
-      @adapter = GnipApi::Adapter.new
-      @request = GnipApi::Request.new_get(@uri)
-    end
-
-    it 'returns a body' do
-      result = @adapter.get @request
-      expect(result).to eq('get_result') # Defined at spec/lib/test_adapter.rb
-    end
-  end
-
-  describe '#post' do
-    before do
-      configure_gem
-      @adapter = GnipApi::Adapter.new
-      @request = GnipApi::Request.new_post(@uri, 'some_payload')
-    end
-
-    it 'returns a body' do
-      result = @adapter.post @request
-      expect(result).to eq('post_result') # Defined at spec/lib/test_adapter.rb
-    end
-  end
-
-  describe '#delete' do
-    before do
-      configure_gem
-      @adapter = GnipApi::Adapter.new
-      @request = GnipApi::Request.new_delete(@uri, 'some_payload')
-    end
-
-    it 'returns a body' do
-      result = @adapter.delete @request
-      expect(result).to eq('delete_result') # Defined at spec/lib/test_adapter.rb
-    end
-  end
-
-  describe '#check_response_for_errors' do
-    before{ configure_gem }
-    let(:adapter) { GnipApi::Adapter.new }
-    let(:request) { GnipApi::Request.new_get(@uri) }
-    
-    context 'when is ok' do
-      let(:response) { GnipApi::Response.new(request, 200, 'good body', {}) }
-      it('does not throw exception') { expect(Proc.new{adapter.check_response_for_errors(response)}).not_to raise_error }
-    end
-
-    context 'when rate limited' do
-      let(:error_message){ {"error"=>{"message"=>"Exceeded rate limit", "sent"=>"2017-06-05T16:20:43+00:00", "transactionId"=>"00629e29000a91c1"}}.to_json }
-      let(:response) { GnipApi::Response.new(request, 429, error_message, {}) }
-      it('raises RateLimitError') { expect(Proc.new{adapter.check_response_for_errors(response)}).to raise_error(GnipApi::Errors::Adapter::RateLimitError) }
-    end
-
-    context 'when software error' do
-      let(:error_message){ {"error"=>{"message"=>"some server error", "sent"=>"2017-06-05T16:20:43+00:00", "transactionId"=>"00629e29000a91c1"}}.to_json }
-      let(:response) { GnipApi::Response.new(request, 503, error_message, {}) }
-      it('raises GnipSoftwareError') { expect(Proc.new{adapter.check_response_for_errors(response)}).to raise_error(GnipApi::Errors::Adapter::GnipSoftwareError) }
-    end
-
-    context 'when other error' do
-      let(:error_message){ {"error"=>{"message"=>"Exceeded rate limit", "sent"=>"2017-06-05T16:20:43+00:00", "transactionId"=>"00629e29000a91c1"}}.to_json }
-      let(:response) { GnipApi::Response.new(request, 400, error_message, {}) }
-      it('raises generic error') { expect(Proc.new{adapter.check_response_for_errors(response)}).to raise_error(GnipApi::Errors::Adapter::RequestError) }
-    end
-
-  end
-
 end

data/spec/gnip_api/configuration_spec.rb

@@ -1,20 +1,6 @@
 require 'spec_helper'
 
 describe GnipApi::Configuration do
-  describe 'OUTPUT_FORMATS' do
-    it 'includes :json' do
-      expect(GnipApi::Configuration::OUTPUT_FORMATS.include?(:json)).to eq(true)
-    end
-
-    it 'includes :activity' do
-      expect(GnipApi::Configuration::OUTPUT_FORMATS.include?(:activity)).to eq(true)
-    end
-
-    it 'includes :parsed_json' do
-      expect(GnipApi::Configuration::OUTPUT_FORMATS.include?(:parsed_json)).to eq(true)
-    end
-  end
-
   describe '#new' do
     it 'has the default values' do
       config = GnipApi::Configuration.new
@@ -22,7 +8,6 @@ describe GnipApi::Configuration do
       expect(config.user).to eq(nil)
       expect(config.password).to eq(nil)
       expect(config.account).to eq(nil)
-      expect(config.adapter_class).to eq(GnipApi::Adapters::HTTPartyAdapter)
       expect(config.logger).not_to eq(nil)
       expect(config.source).to eq(nil)
       expect(config.label).to eq(nil)

data/spec/gnip_api/{apis/power_track → power_track}/buffer_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe GnipApi::Apis::PowerTrack::Buffer do
+describe GnipApi::PowerTrack::Buffer do
   before do
-    @buffer = GnipApi::Apis::PowerTrack::Buffer.new(:terminator => '--')
+    @buffer = GnipApi::PowerTrack::Buffer.new(:terminator => '--')
   end
   
   it 'has "--" as terminator char' do

data/spec/gnip_api/power_track/rule_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+def consistent_values
+  @consistent_values ||= JSON.parse(read_fixture('rule_value_examples.json'))['consistent']
+end
+
+def inconsistent_values
+  @inconsistent_values ||= JSON.parse(read_fixture('rule_value_examples.json'))['inconsistent']
+end
+
+describe GnipApi::PowerTrack::Rule do
+  subject(:rule_class){ GnipApi::PowerTrack::Rule }
+  before do
+    configure_gem
+  end
+  
+  it 'creates a rule' do
+    expect(Proc.new{rule_class.new}).not_to raise_error
+  end
+
+  describe 'rule' do
+    let(:value){ 'something' }
+    let(:tag){ 'tag' }
+    let(:rule) {rule_class.new(:value => value, :tag => tag) }
+
+    it('has a value'){ expect(rule.value).to eq(value) }
+    it('has a tag'){ expect(rule.tag).to eq(tag) }
+  end
+
+  describe '#attributes' do
+    context 'with tag' do
+      let(:rule){ rule_class.new(:value => 'r1', :tag => 't1') }
+      let(:expected_attributes){ {:value => 'r1', :tag => 't1'} }
+      
+      it('returns expected attributes'){ expect(rule.attributes).to eq(expected_attributes) }
+    end
+
+    context 'without tag' do
+      let(:rule){ rule_class.new(:value => 'r1') }
+      let(:expected_attributes){ {:value => 'r1'} }
+      
+      it('returns expected attributes'){ expect(rule.attributes).to eq(expected_attributes) }
+    end
+  end
+
+  describe '#to_json' do
+    let(:rule) { rule_class.new(:value => 'value', :tag => 'tag') }
+    let(:json) { {:value => 'value', :tag => 'tag'}.to_json }
+    
+    it('converts to json'){ expect(rule.to_json).to eq(json) }
+  end
+
+  describe '#consistent?' do
+    let(:rule) { rule_class.new }
+    
+    context 'without raising exception' do
+      consistent_values.each do |value|
+        it "returns true for consistent value #{value}" do
+          rule.value = value
+          expect(rule.consistent?).to eq(true)
+        end
+      end
+
+      inconsistent_values.each do |value|
+        it "returns false for inconsistent value #{value}" do
+          rule.value = value
+          expect(rule.consistent?).to eq(false)
+        end
+      end
+    end
+
+    context 'when raising exception' do
+      consistent_values.each do |value|
+        it "returns nil for consistent #{value}" do
+          rule.value = value
+          expect(rule.consistent?(true)).to eq(nil)
+        end
+      end
+
+      inconsistent_values.each do |value|
+        it "raises ArgumentError for inconsistent value #{value}" do
+          rule.value = value
+          expect(Proc.new{rule.consistent?(true)}).to raise_error(ArgumentError)
+        end
+      end
+    end
+
+  end
+end

data/spec/gnip_api/{apis/power_track → power_track}/rules_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
-describe GnipApi::Apis::PowerTrack::Rules do
+describe GnipApi::PowerTrack::Rules do
   before do
-    @api = GnipApi::Apis::PowerTrack::Rules.new(:source => 'source', :label => 'label')
-    @rules = [GnipApi::Apis::PowerTrack::Rule.new(:value => 'r1', :tag => 't1'),
-              GnipApi::Apis::PowerTrack::Rule.new(:value => 'r2')]
+    @api = GnipApi::PowerTrack::Rules.new(:source => 'source', :label => 'label')
+    @rules = [GnipApi::PowerTrack::Rule.new(:value => 'r1', :tag => 't1'),
+              GnipApi::PowerTrack::Rule.new(:value => 'r2')]
     @json = {:rules => [{:value => 'r1', :tag => 't1'}, {:value => 'r2'}]}.to_json
   end
 
   describe '#parse_rules' do
-    it 'parses json rules to GnipApi::Apis::PowerTrack::Rule objects' do
+    it 'parses json rules to GnipApi::PowerTrack::Rule objects' do
       parsed = @api.parse_rules(@json)
-      expect(parsed.first.class).to eq(GnipApi::Apis::PowerTrack::Rule)
+      expect(parsed.first.class).to eq(GnipApi::PowerTrack::Rule)
     end
   end
 
@@ -48,9 +48,9 @@ describe GnipApi::Apis::PowerTrack::Rules do
       expect(result.size).to eq(2)
     end
 
-    it 'returns GnipApi::Apis::PowerTrack::Rule objects' do
+    it 'returns GnipApi::PowerTrack::Rule objects' do
       result = @api.list
-      expect(result.map(&:class).uniq).to eq([GnipApi::Apis::PowerTrack::Rule])
+      expect(result.map(&:class).uniq).to eq([GnipApi::PowerTrack::Rule])
     end
 
     describe 'rules fetched' do

data/spec/gnip_api/power_track/stream_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe GnipApi::PowerTrack::Stream do
+  before do
+    configure_gem
+    @stream = GnipApi::PowerTrack::Stream.new
+  end
+
+  describe '#initialize' do
+  end
+
+  describe '#process_entries' do
+    before do
+      @json = File.read('spec/fixtures/activities/real_activity.json')
+    end
+    
+    it 'bulds a Message object from the json' do
+      message = @stream.process_entries([@json])
+      expect(message.first.class).to eq(Gnip::Activity)
+    end
+    
+    it 'returns empty array if could not parse json' do
+      message = @stream.process_entries(['lol'])
+      expect(message).to eq([])
+    end
+  end
+
+  describe '#parse_json' do
+    before do
+      @json = File.read('spec/fixtures/activities/real_activity.json')
+    end
+
+    it 'does not throw error with activity json' do
+      expect(Proc.new{@stream.parse_json(@json)}).not_to raise_error
+    end
+
+    it 'parses json' do
+      parsed = @stream.parse_json @json
+      expect(parsed.class).to eq(Hash)
+    end
+
+    it 'returns nil if empty json is passed' do
+      parsed = @stream.parse_json('')
+      expect(parsed).to eq(nil)
+    end
+    
+    it 'returns nil if invalid json is passed' do
+      parsed = @stream.parse_json('12,4.,x_VZxuv8{ak{f}}}}} {{ (d(s)aa(((aaaaa)aaa)')
+      expect(parsed).to eq(nil)
+    end
+    
+  end
+end

data/spec/gnip_api/response_spec.rb

@@ -29,4 +29,31 @@ describe GnipApi::Response do
     end
 
   end
+
+  describe '#check_for_errors!' do
+    let(:request) { GnipApi::Request.new_get(@uri) }
+    context 'when is ok' do
+      let(:response) { GnipApi::Response.new(request, 200, 'good body', {}) }
+      it('does not throw exception') { expect(Proc.new{response.check_for_errors!}).not_to raise_error }
+    end
+
+    context 'when rate limited' do
+      let(:error_message){ {"error"=>{"message"=>"Exceeded rate limit", "sent"=>"2017-06-05T16:20:43+00:00", "transactionId"=>"00629e29000a91c1"}}.to_json }
+      let(:response) { GnipApi::Response.new(request, 429, error_message, {}) }
+      it('raises RateLimitError') { expect(Proc.new{response.check_for_errors!}).to raise_error(GnipApi::Errors::Adapter::RateLimitError) }
+    end
+
+    context 'when software error' do
+      let(:error_message){ {"error"=>{"message"=>"some server error", "sent"=>"2017-06-05T16:20:43+00:00", "transactionId"=>"00629e29000a91c1"}}.to_json }
+      let(:response) { GnipApi::Response.new(request, 503, error_message, {}) }
+      it('raises GnipSoftwareError') { expect(Proc.new{response.check_for_errors!}).to raise_error(GnipApi::Errors::Adapter::GnipSoftwareError) }
+    end
+
+    context 'when other error' do
+      let(:error_message){ {"error"=>{"message"=>"Exceeded rate limit", "sent"=>"2017-06-05T16:20:43+00:00", "transactionId"=>"00629e29000a91c1"}}.to_json }
+      let(:response) { GnipApi::Response.new(request, 400, error_message, {}) }
+      it('raises generic error') { expect(Proc.new{response.check_for_errors!}).to raise_error(GnipApi::Errors::Adapter::RequestError) }
+    end
+  end
+
 end

data/spec/gnip_api/{apis/search_spec.rb → search_spec.rb}

@@ -1,18 +1,18 @@
 require 'spec_helper'
 
-describe GnipApi::Apis::Search do
+describe GnipApi::Search do
   describe '.new' do
     it 'creates search instance' do
-      object = GnipApi::Apis::Search.new
+      object = GnipApi::Search.new
       expect(object).not_to eq(nil)
-      expect(object.class).to eq(GnipApi::Apis::Search)
+      expect(object.class).to eq(GnipApi::Search)
     end
   end
 
   describe '#counts' do
     before do
       @raw_response = File.read(fixture_path.join('search_api/search_counts_response.json'))
-      @api = GnipApi::Apis::Search.new
+      @api = GnipApi::Search.new
       allow(@api.adapter).to receive(:post).and_return(@raw_response)
     end
 
@@ -21,14 +21,14 @@ describe GnipApi::Apis::Search do
     end
 
     it 'performs request and parses response' do
-      rule = GnipApi::Apis::PowerTrack::Rule.new :value => 'lolcat OR madcat'
+      rule = GnipApi::PowerTrack::Rule.new :value => 'lolcat OR madcat'
       result = @api.counts :rule => rule
       expect(result).not_to eq(nil)
     end
 
     describe 'result set' do
       before do
-        rule = GnipApi::Apis::PowerTrack::Rule.new :value => 'lolcat OR madcat'
+        rule = GnipApi::PowerTrack::Rule.new :value => 'lolcat OR madcat'
         @result = @api.counts :rule => rule
       end
 
@@ -65,7 +65,7 @@ describe GnipApi::Apis::Search do
   describe '#activities' do
     before do
       @raw_response = File.read(fixture_path.join('search_api/search_activities_response.json'))
-      @api = GnipApi::Apis::Search.new
+      @api = GnipApi::Search.new
       allow(@api.adapter).to receive(:post).and_return(@raw_response)
     end
 
@@ -74,14 +74,14 @@ describe GnipApi::Apis::Search do
     end
 
     it 'performs request and parses response' do
-      rule = GnipApi::Apis::PowerTrack::Rule.new :value => 'lolcat OR madcat'
+      rule = GnipApi::PowerTrack::Rule.new :value => 'lolcat OR madcat'
       result = @api.activities :rule => rule
       expect(result).not_to eq(nil)
     end
 
     describe 'result set' do
       before do
-        rule = GnipApi::Apis::PowerTrack::Rule.new :value => 'lolcat OR madcat'
+        rule = GnipApi::PowerTrack::Rule.new :value => 'lolcat OR madcat'
         @result = @api.activities :rule => rule
       end
 

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
 require 'gnip_api'
 require 'pry'
-require 'lib/test_adapter.rb'
 require 'timecop'
 
 def configure_gem
@@ -8,14 +7,16 @@ def configure_gem
     config.user = "someone"
     config.password = "lolcat"
     config.account = "something"
-    config.adapter_class = TestAdapter
     config.source = 'twitter'
     config.label = 'prod'
     config.debug = false
-    config.stream_output_format = :activity
   end
 end
 
 def fixture_path
   Pathname.new('spec/fixtures')
 end
+
+def read_fixture path
+  File.read(fixture_path.join(path))
+end