da_face 0.0.1

data/spec/da_face/api/adapters/base_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe DaFace::Api::Adapters::Base do
+  before do
+    DaFace.configure do |config|
+      config.api_path_prefix = '/lolcat'
+      config.api_host = 'http://host.com'
+      config.user = 'lol'
+      config.api_key = 'cat'
+    end
+  end
+
+  it 'throws error if user is missing' do
+    DaFace.configuration.user = nil
+    expect(Proc.new{DaFace::Api::Adapters::Base.new}).to raise_error(DaFace::AdapterError)
+  end
+
+  it 'throws error if api_key is missing' do
+    DaFace.configuration.api_key = nil
+    expect(Proc.new{DaFace::Api::Adapters::Base.new}).to raise_error(DaFace::AdapterError)
+  end
+
+  describe '#default_headers' do
+    before do
+      @adapter = DaFace::Api::Adapters::Base.new
+    end
+
+    it 'constructs default header hash' do
+      headers = @adapter.default_headers
+
+      expect(headers.keys).to eq(['Authorization', 'Accept'])
+      expect(headers.values.compact.size).not_to eq(0)
+    end
+
+    it 'constructs post header hash' do
+      headers = @adapter.post_headers
+
+      expect(headers.keys).to eq(['Authorization', 'Accept', 'Content-Type'])
+      expect(headers.values.compact.size).not_to eq(0)
+    end
+
+    it 'constructs get header hash' do
+      headers = @adapter.get_headers
+
+      expect(headers.keys).to eq(['Authorization', 'Accept'])
+      expect(headers.values.compact.size).not_to eq(0)
+    end
+  end
+
+  describe '#host' do
+    before do
+      @adapter = DaFace::Api::Adapters::Base.new
+    end
+
+    it 'uses DaFace.configuration value' do
+      expect(@adapter.host).to eq(DaFace.configuration.api_host)
+    end
+  end
+
+  describe '#path_prefix' do
+    before do
+      @adapter = DaFace::Api::Adapters::Base.new
+    end
+
+    it 'uses DaFace.configuration value' do
+      expect(@adapter.path_prefix).to eq(DaFace.configuration.api_path_prefix)
+    end
+  end
+
+
+  describe '#user' do
+    before do
+      @adapter = DaFace::Api::Adapters::Base.new
+    end
+
+    it 'uses DaFace.configuration value' do
+      expect(@adapter.user).to eq(DaFace.configuration.user)
+    end
+  end
+
+
+  describe '#api_key' do
+    before do
+      @adapter = DaFace::Api::Adapters::Base.new
+    end
+
+    it 'uses DaFace.configuration value' do
+      expect(@adapter.api_key).to eq(DaFace.configuration.api_key)
+    end
+  end
+
+  describe '#api_path' do
+    before do
+      @adapter = DaFace::Api::Adapters::Base.new
+    end
+
+    it 'constructs base path for requests' do
+      expect(@adapter.api_path).to eq('http://host.com/lolcat')
+    end
+  end
+
+  describe '#api_auth_header' do
+    before do
+      @adapter = DaFace::Api::Adapters::Base.new
+    end
+
+    it 'constructs correct auth header' do
+      expect(@adapter.api_auth_header).to eq('lol:cat')
+    end
+  end
+
+  describe '#url_params' do
+    before do
+      @params = {:lol => 'lol', :cat => 'cat'}
+      @adapter = DaFace::Api::Adapters::Base.new
+    end
+
+    it 'parses params hash to uri params' do
+      expect(@adapter.url_params(@params)).to eq('?lol=lol&cat=cat')
+    end
+  end
+
+
+
+end

data/spec/da_face/api/push_log_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper' 
+
+describe DaFace::Api::PushLog do
+  before do
+    DaFace.configure do |config|
+      config.user = 'someone'
+      config.api_key = 'something'
+    end
+
+    fixture = json_fixture('api_responses/log.json')
+    # TODO Make this tool preetier (symbolize)
+    @log_data = DaFace::Api::Adapter.new.symbolize_keys(fixture.keys, fixture)
+  end
+  describe '#new' do
+    it 'creates a PushLog object' do
+      obj = DaFace::Api::PushLog.new @log_data
+      
+      expect(obj.class).to eq(DaFace::Api::PushLog)
+    end
+  end
+
+  describe 'attributes' do
+    before do
+      @push_log = DaFace::Api::PushLog.new @log_data
+    end
+
+    it 'has required attributes' do
+      expect(@push_log.count).to eq(@log_data[:count])
+      expect(@push_log.entries.class).to eq(Array)
+      expect(@push_log.entries.size).not_to eq(0)
+      expect(@push_log.entries.map(&:class).uniq).to eq([DaFace::Api::PushLogEntry])
+    end
+  end
+end

data/spec/da_face/api/push_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper' 
+
+describe DaFace::Api::Push do
+  before do
+    DaFace.configure do |config|
+      config.api_path_prefix = '/lolcat'
+      config.api_host = 'http://host.com'
+      config.user = 'lol'
+      config.api_key = 'cat'
+    end
+    @adapter = DaFace::Api::Adapter.new
+    @excon_adapter = DaFace::Api::Adapters::ExconAdapter.new
+    @conn = Excon.new 'http://host.com/lolcat', :mock => true
+    allow(@excon_adapter).to receive(:connection).and_return(@conn)
+    allow(@adapter).to receive(:connection).and_return(@excon_adapter)
+    allow(DaFace::Api::Push).to receive(:connection).and_return(@adapter)
+  end
+
+  describe '.get' do
+    before do
+      Excon.stub({:path => '/push/get'}, 
+                 {:body => json_fixture('api_responses/get_subscriptions.json').to_json, :status => 200})
+    end
+
+    it 'returns subscription list' do
+      data = DaFace::Api::Push.get
+      expect(data).not_to eq(nil)
+      expect(data.class).to eq(Hash)
+    end
+  end
+
+  describe '.log' do
+    before do
+      Excon.stub({:path => '/push/log?id=some_sub_id'}, 
+                 {:body => json_fixture('api_responses/log.json').to_json, :status => 200})
+    end
+
+    it 'returns a log list' do
+      data = DaFace::Api::Push.log 'some_sub_id'
+      expect(data).not_to eq(nil)
+      expect(data[:log_entries].size).not_to eq(0)
+    end
+  end
+
+  describe '.stop' do
+    before do
+      Excon.stub({:path => '/push/stop'}, 
+                 {:status => 200})
+    end
+
+    it 'returns true when stopping' do
+      data = DaFace::Api::Push.stop 'some_sub_id'
+      expect(data).not_to eq(nil)
+      expect(data).to eq(true)
+    end
+  end
+
+  describe '.pause' do
+    before do
+      Excon.stub({:path => '/push/pause'}, 
+                 {:status => 200})
+    end
+
+    it 'returns true when pausing' do
+      data = DaFace::Api::Push.pause 'some_sub_id'
+      expect(data).not_to eq(nil)
+      expect(data).to eq(true)
+    end
+  end
+
+  describe '.resume' do
+    before do
+      Excon.stub({:path => '/push/resume'}, 
+                 {:status => 200})
+    end
+
+    it 'returns true when resuming' do
+      data = DaFace::Api::Push.resume 'some_sub_id'
+      expect(data).not_to eq(nil)
+      expect(data).to eq(true)
+    end
+  end
+
+  describe '.validate' do
+    before do
+      Excon.stub({:path => '/push/validate'}, 
+                 {:body => json_fixture('api_responses/validate_success.json').to_json, :status => 200})
+    end
+
+    it 'validates output_params' do
+      data = DaFace::Api::Push.validate :some_output => 'output'
+      expect(data).not_to eq(nil)
+      expect(data[:message]).to eq('Validated successfully')
+    end
+  end
+
+  describe '.create' do
+    before do
+      Excon.stub({:path => '/push/create'}, 
+                 {:status => 200})
+    end
+
+    it 'creates a subscription in datasift' do
+      data = DaFace::Api::Push.create :some_sub => 'data'
+      expect(data).not_to eq(nil)
+    end
+  end
+end

data/spec/da_face/api/push_subscription_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+describe DaFace::Api::PushSubscription do
+  before do
+    @attrs = {
+      :id => "k3j452kl3j4h5kl23j45h2l34kjh5345",
+      :output_type => "http",
+      :name => "SomeName",
+      :created_at => 1412345259,
+      :user_id => 28949,
+      :hash => "1m2n3bm12n3b1n23bm1n2b3mn12b3m2n",
+      :hash_type => "stream",
+      :output_params => {
+        :max_size => 2097152,
+        :delivery_frequency => 0,
+        :url => "http =>//somewhere.com/data_receiver"
+      },
+      :status => "active",
+      :last_request => 1412597788,
+      :last_success => 1412597789,
+      :remaining_bytes => 100,
+      :lost_data => false,
+      :start => 1412345259,
+      :end => 1412347259
+    }
+  end
+
+  describe '#new' do
+    it 'creates a PushSubscription object' do
+      obj = DaFace::Api::PushSubscription.new @attrs
+
+      expect(obj.class).to eq(DaFace::Api::PushSubscription)
+    end
+    
+    it 'creates enpty Pushsubscription' do
+      expect(Proc.new{DaFace::Api::PushSubscription.new}).not_to raise_error
+    end
+  end
+
+  describe 'attributes' do
+    before do
+      @subscription = DaFace::Api::PushSubscription.new @attrs
+    end
+
+    describe '#id' do
+      it 'is present' do
+        expect(@subscription.id).to eq(@attrs[:id])
+      end
+    end
+
+    describe '#name' do
+      it 'is present' do
+        expect(@subscription.name).to eq(@attrs[:name])
+      end
+    end
+
+    describe '#created_at' do
+      it 'is present' do
+        expect(@subscription.created_at).to eq(Time.at(@attrs[:created_at]))
+      end
+    end
+
+    describe '#user_id' do
+      it 'is present' do
+        expect(@subscription.hash).to eq(@attrs[:hash])
+      end
+    end
+
+    describe '#hash_type' do
+      it 'is present' do
+        expect(@subscription.hash_type).to eq(@attrs[:hash_type])
+      end
+    end
+
+    describe '#status' do
+      it 'is present' do
+        expect(@subscription.status).to eq(@attrs[:status])
+      end
+    end
+
+    describe '#last_request' do
+      it 'is present' do
+        expect(@subscription.last_request).to eq(Time.at(@attrs[:last_request]))
+      end
+    end
+
+    describe '#last_success' do
+      it 'is present' do
+        expect(@subscription.last_success).to eq(Time.at(@attrs[:last_success]))
+      end
+    end
+
+    describe '#remaining_bytes' do
+      it 'is present' do
+        expect(@subscription.remaining_bytes).to eq(@attrs[:remaining_bytes])
+      end
+    end
+
+    describe '#lost_data' do
+      it 'is present' do
+        expect(@subscription.lost_data).to eq(@attrs[:lost_data])
+      end
+    end
+
+    describe '#lost_data?' do
+      it 'returns same as #lost_data' do
+        expect(@subscription.lost_data?).to eq(@subscription.lost_data)
+      end
+    end
+
+    describe '#start' do
+      it 'is present' do
+        expect(@subscription.start).to eq(Time.at(@attrs[:start]))
+      end
+    end
+
+    describe '#end' do
+      it 'is present' do
+        expect(@subscription.end).to eq(Time.at(@attrs[:end]))
+      end
+    end
+
+    describe '#output_type' do
+      it 'is present' do
+        expect(@subscription.output_type).to eq(@attrs[:output_type])
+      end
+    end
+
+    describe '#output_params' do
+      it 'is present' do
+        expect(@subscription.output_params).to eq(@attrs[:output_params])
+      end
+    end
+  end
+
+  describe 'configs' do
+    before do
+      @attrs = {
+        :output_type => "http",
+        :name => "SomeName",
+        :hash => "l3k4j23k4jl23j42l3k4j2l3kj4k3j4l",
+        :output_params => {
+          :auth => {
+            :type => 'none'
+          },
+          :max_size => 2097152,
+          :delivery_frequency => 0,
+          :url => "http =>//someurl.com/someendpoint"
+        },
+        :start => 1412345259,
+        :end => 1412375259
+      }
+
+      @config = {
+        'output_type' => 'http',
+        'name' => 'SomeName',
+        'hash' => 'l3k4j23k4jl23j42l3k4j2l3kj4k3j4l',
+        'start' => 1412345259,
+        'end' => 1412375259,
+        'output_params.max_size' => 2097152,
+        'output_params.delivery_frequency' => 0,
+        'output_params.url' => "http =>//someurl.com/someendpoint",
+        'output_params.auth.type' => 'none'
+      }
+
+      @output_params_config = {
+        'output_params.max_size' => 2097152,
+        'output_params.delivery_frequency' => 0,
+        'output_params.url' => "http =>//someurl.com/someendpoint",
+        'output_params.auth.type' => 'none'
+      }
+
+      @output_config = {
+        'output_type' => 'http',
+        'output_params.max_size' => 2097152,
+        'output_params.delivery_frequency' => 0,
+        'output_params.url' => "http =>//someurl.com/someendpoint",
+        'output_params.auth.type' => 'none'
+      }
+
+
+      @subscription = DaFace::Api::PushSubscription.new @attrs
+    end
+
+    it 'generates config' do
+      expect(@subscription.generate_config).to eq(@config)
+    end
+
+    it 'generates output_params config' do
+      expect(@subscription.output_params_config).to eq(@output_params_config)
+    end
+
+    it 'generates output_config config' do
+      expect(@subscription.output_config).to eq(@output_config)
+    end
+
+  end
+
+  # describe '#validate' do
+  #   before do
+  #     @attrs = {
+  #       :output_type => "http",
+  #       :name => "SomeName",
+  #       :hash => "fc79ca5fefdb54b72292db503d686257",
+  #       :output_params => {
+  #         :max_size => 2097152,
+  #         :delivery_frequency => 0,
+  #         :url => "http =>//someurl.com/someendpoint"
+  #       },
+  #       :start => 1412345259,
+  #       :end => 1412375259
+  #     }
+  #     @subscription = DaFace::Api::PushSubscription.new @attrs
+  #   end
+    
+  #   it 'validates against Datasift' do
+  #     expect(@subscription.validate).to eq(true)
+  #   end
+  # end
+end

data/spec/da_face/configuration_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe DaFace::Configuration do
+  describe '#new' do
+    it 'has the default values' do
+      config = DaFace::Configuration.new
+
+      expect(config.api_path_prefix).to eq('/v1')
+      expect(config.api_host).to eq('http://api.datasift.com')
+      expect(config.adapter_class).to eq(DaFace::Api::Adapters::ExconAdapter)
+      expect(config.user).to eq(nil)
+      expect(config.api_key).to eq(nil)
+    end
+  end
+end

data/spec/da_face/datasift/da_object_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe DaFace::Datasift::DaObject do
+  before do
+    @parser = DaFace::Datasift::Parser.new
+    fixture = json_fixture('interactions/simple.json')
+    @interaction_data = @parser.symbolize_keys(fixture.keys, fixture)
+  end
+
+  describe '#new' do
+    it 'creates a DaObject object' do
+      obj = DaFace::Datasift::DaObject.new @interaction_data
+
+      expect(obj.class).to eq(DaFace::Datasift::DaObject)
+    end
+
+    it 'creates empty DaObject' do
+      expect(Proc.new{DaFace::Datasift::DaObject.new}).not_to raise_error
+    end
+  end
+
+  describe 'attributes' do
+    before do 
+      @da_object = DaFace::Datasift::DaObject.new @interaction_data
+    end
+
+    describe '#interaction' do
+      it 'is present' do
+        expect(@da_object.interaction).not_to eq(nil)
+      end
+    end
+
+    describe '#demographic' do
+      it 'is present' do
+        expect(@da_object.demographic).not_to eq(nil)
+      end
+    end
+
+    describe '#salience' do
+      it 'is present' do
+        expect(@da_object.salience).not_to eq(nil)
+      end
+    end
+
+    describe '#links' do
+      it 'is present' do
+        expect(@da_object.links).not_to eq(nil)
+      end
+    end
+    
+    describe '#twitter' do
+      it 'is present' do
+        expect(@da_object.twitter).not_to eq(nil)
+      end
+    end
+
+    describe '#language' do
+      it 'is present' do
+        expect(@da_object.language).not_to eq(nil)
+      end
+    end
+
+    describe '#kind' do
+      it 'is present' do
+        expect(@da_object.kind).to eq(DaFace::Datasift::DaObject::TWITTER_INTERACTION)
+      end
+    end
+  end
+
+
+
+
+  context 'suspend message' do
+    before do
+      fixture = json_fixture('notifications/user_suspend.json')
+      @data = @parser.symbolize_keys(fixture.keys, fixture)
+      @da_object = DaFace::Datasift::DaObject.new @data
+    end
+
+    it 'creates a twitter user status message' do
+      expect(@da_object.twitter.class).to eq(DaFace::Datasift::TwitterUserStatus)
+      expect(@da_object.kind).to eq(DaFace::Datasift::DaObject::TWITTER_USER_NOTIFICATION)
+    end
+
+    it 'has proper status value' do
+      expect(@da_object.twitter.status).to eq(DaFace::Datasift::TwitterUserStatus::STATUS_SUSPEND)
+    end
+  end
+
+  context 'unsuspend message' do
+    before do
+      fixture = json_fixture('notifications/user_unsuspend.json')
+      @data = @parser.symbolize_keys(fixture.keys, fixture)
+      @da_object = DaFace::Datasift::DaObject.new @data
+    end
+
+    it 'creates a twitter user status message' do
+      expect(@da_object.twitter.class).to eq(DaFace::Datasift::TwitterUserStatus)
+      expect(@da_object.kind).to eq(DaFace::Datasift::DaObject::TWITTER_USER_NOTIFICATION)
+    end
+
+    it 'has proper status value' do
+      expect(@da_object.twitter.status).to eq(DaFace::Datasift::TwitterUserStatus::STATUS_UNSUSPEND)
+    end
+  end
+
+
+  context 'delete user message' do
+    before do
+      fixture = json_fixture('notifications/user_delete.json')
+      @data = @parser.symbolize_keys(fixture.keys, fixture)
+      @da_object = DaFace::Datasift::DaObject.new @data
+    end
+
+    it 'creates a twitter user status message' do
+      expect(@da_object.twitter.class).to eq(DaFace::Datasift::TwitterUserStatus)
+      expect(@da_object.kind).to eq(DaFace::Datasift::DaObject::TWITTER_USER_NOTIFICATION)
+    end
+
+    it 'has proper status value' do
+      expect(@da_object.twitter.status).to eq(DaFace::Datasift::TwitterUserStatus::STATUS_DELETE)
+    end
+  end
+
+  context 'undelete message' do
+    before do
+      fixture = json_fixture('notifications/user_undelete.json')
+      @data = @parser.symbolize_keys(fixture.keys, fixture)
+      @da_object = DaFace::Datasift::DaObject.new @data
+    end
+
+    it 'creates a twitter user status message' do
+      expect(@da_object.twitter.class).to eq(DaFace::Datasift::TwitterUserStatus)
+      expect(@da_object.kind).to eq(DaFace::Datasift::DaObject::TWITTER_USER_NOTIFICATION)
+    end
+
+    it 'has proper status value' do
+      expect(@da_object.twitter.status).to eq(DaFace::Datasift::TwitterUserStatus::STATUS_UNDELETE)
+    end
+  end
+
+  context 'protect message' do
+    before do
+      fixture = json_fixture('notifications/user_protect.json')
+      @data = @parser.symbolize_keys(fixture.keys, fixture)
+      @da_object = DaFace::Datasift::DaObject.new @data
+    end
+
+    it 'creates a twitter user status message' do
+      expect(@da_object.twitter.class).to eq(DaFace::Datasift::TwitterUserStatus)
+      expect(@da_object.kind).to eq(DaFace::Datasift::DaObject::TWITTER_USER_NOTIFICATION)
+    end
+
+    it 'has proper status value' do
+      expect(@da_object.twitter.status).to eq(DaFace::Datasift::TwitterUserStatus::STATUS_PROTECT)
+    end
+  end
+
+  context 'unprotect message' do
+    before do
+      fixture = json_fixture('notifications/user_unprotect.json')
+      @data = @parser.symbolize_keys(fixture.keys, fixture)
+      @da_object = DaFace::Datasift::DaObject.new @data
+    end
+
+    it 'creates a twitter user status message' do
+      expect(@da_object.twitter.class).to eq(DaFace::Datasift::TwitterUserStatus)
+      expect(@da_object.kind).to eq(DaFace::Datasift::DaObject::TWITTER_USER_NOTIFICATION)
+    end
+
+    it 'has proper status value' do
+      expect(@da_object.twitter.status).to eq(DaFace::Datasift::TwitterUserStatus::STATUS_UNPROTECT)
+    end
+  end
+
+
+
+  context 'delete message' do
+    before do
+      fixture = json_fixture('notifications/delete.json')
+      @data = @parser.symbolize_keys(fixture.keys, fixture)
+      @da_object = DaFace::Datasift::DaObject.new @data
+    end
+
+    it 'creates a twitter delete message' do
+      expect(@da_object.twitter.class).to eq(DaFace::Datasift::TwitterDeleteNotification)
+      expect(@da_object.kind).to eq(DaFace::Datasift::DaObject::TWITTER_DELETE_NOTIFICATION)
+    end
+  end
+
+end