datasift 3.1.5 → 3.2.0

data/lib/pylon.rb

@@ -0,0 +1,122 @@
+module DataSift
+  #
+  # Class for accessing DataSift's PYLON API
+  class Pylon < DataSift::ApiResource
+    # Check PYLON CSDL is valid by making an /pylon/validate API call
+    #
+    # @param csdl [String] CSDL you wish to validate
+    # @param boolResponse [Boolean] True if you want a boolean response.
+    #   False if you want the full response object
+    # @return [Boolean, Object] Dependent on value of boolResponse
+    def valid?(csdl = '', boolResponse = true)
+      fail BadParametersError, 'csdl is required' if csdl.empty?
+      params = { csdl: csdl }
+
+      res = DataSift.request(:POST, 'pylon/validate', @config, params)
+      boolResponse ? res[:http][:status] == 200 : res
+    end
+
+    # Compile PYLON CSDL by making an /pylon/compile API call
+    #
+    # @param csdl [String] CSDL you wish to compile
+    # @return [Object] API reponse object
+    def compile(csdl)
+      fail BadParametersError, 'csdl is required' if csdl.empty?
+      params = { csdl: csdl }
+
+      DataSift.request(:POST, 'pylon/compile', @config, params)
+    end
+
+    # Perform /pylon/get API call to query status of your PYLON recordings
+    #
+    # @param hash [String] Hash you with the get the status for
+    # @return [Object] API reponse object
+    def get(hash)
+      fail BadParametersError, 'hash is required' if hash.empty?
+      params = { hash: hash }
+
+      DataSift.request(:GET, 'pylon/get', @config, params)
+    end
+
+    # Perform /pylon/get API call to list all PYLON Recordings
+    #
+    # @param page [Integer] Which page of recordings to retreive
+    # @param per_page [Integer] How many recordings to return per page
+    # @param order_by [String, Symbol] Which field to sort results by
+    # @param order_dir [String, Symbol] Order results in ascending or descending
+    #   order
+    # @return [Object] API reponse object
+    def list(page = nil, per_page = nil, order_by = '', order_dir = '')
+      params = {}
+      params.merge!(page: page) unless page.nil?
+      params.merge!(per_page: per_page) unless per_page.nil?
+      params.merge!(order_by: order_by) unless order_by.empty?
+      params.merge!(order_dir: order_dir) unless order_dir.empty?
+
+      DataSift.request(:GET, 'pylon/get', @config, params)
+    end
+
+    # Start recording a PYLON filter by making an /pylon/start API call
+    #
+    # @param hash [String] CSDL you wish to begin (or resume) recording
+    # @param name [String] Give your recording a name. Required when starting a
+    #   new recording
+    # @return [Object] API reponse object
+    def start(hash = '', name = '')
+      fail BadParametersError, 'hash is required' if hash.empty?
+      params = { hash: hash }
+      params.merge!(name: name) unless name.empty?
+
+      DataSift.request(:PUT, 'pylon/start', @config, params)
+    end
+
+    # Stop an active PYLON recording by making an /pylon/stop API call
+    #
+    # @param hash [String] CSDL you wish to stop recording
+    # @return [Object] API reponse object
+    def stop(hash)
+      fail BadParametersError, 'hash is required' if hash.empty?
+      params = { hash: hash }
+
+      DataSift.request(:PUT, 'pylon/stop', @config, params)
+    end
+
+    # Perform a PYLON analysis query by making an /pylon/analyze API call
+    #
+    # @param hash [String] Hash of the recording you wish to perform an
+    #   analysis against
+    # @param parameters [String] Parameters of the analysis you wish to perform.
+    #   See the
+    #   {http://dev.datasift.com/pylon/docs/api-endpoints/pylonanalyze
+    #   /pylon/analyze API Docs} for full documentation
+    # @param filter [String] Optional PYLON CSDL for a query filter
+    # @param start_time [Integer] Optional start timestamp for filtering by date
+    # @param end_time [Integer] Optional end timestamp for filtering by date
+    # @return [Object] API reponse object
+    def analyze(hash = '', parameters = '', filter = '', start_time = nil, end_time = nil)
+      fail BadParametersError, 'hash is required' if hash.empty?
+      fail BadParametersError, 'parameters is required' if parameters.empty?
+      params = {
+        hash: hash,
+        parameters: parameters
+      }
+      params.merge!(filter: filter) unless filter.empty?
+      params.merge!(start: start_time) unless start_time.nil?
+      params.merge!(end: end_time) unless end_time.nil?
+
+      DataSift.request(:POST, 'pylon/analyze', @config, params)
+    end
+
+    # Query the tag hierarchy on interactions populated by a particular
+    #   recording
+    #
+    # @param hash [String] Hash of the recording you wish to query
+    # @return [Object] API reponse object
+    def tags(hash)
+      fail BadParametersError, 'hash is required' if hash.empty?
+      params = { hash: hash }
+
+      DataSift.request(:GET, 'pylon/tags', @config, params)
+    end
+  end
+end

data/test/datasift/core_api_test.rb

@@ -6,148 +6,174 @@ describe 'DataSift' do
     auth      = DataSiftExample.new
     @datasift = auth.datasift
     @data     = OpenStruct.new
-    @statuses = OpenStruct.new
-    @headers  = OpenStruct.new
 
     @data.valid_csdl    = 'interaction.content contains "test"'
     @data.invalid_csdl  = 'interaction.nonsense is not valid'
+    @data.invalid_hash  = 'this_is_not_a_valid_stream_hash'
+  end
 
-    @statuses.valid        = 200
-    @statuses.bad_request  = 400
-
+  ##
+  # Client
+  #
+  describe 'client' do
+    it 'raises_InvalidConfigError_without_auth_credentials' do
+      assert_raises InvalidConfigError do
+        DataSift::Client.new({})
+      end
+    end
   end
 
-  describe '#compile/validate' do
-    before do
-      @headers.csdl_compile = {
-          "date"              => "Thu, 30 Jan 2014 10:09:19 GMT", "content-type" => "application/json",
-          "transfer-encoding" => "chunked", "connection" => "close", "x-api-version" => "1",
-          "x-ratelimit-limit" => "10000", "x-ratelimit-remaining" => "10000", "x-ratelimit-cost" => "5"}
-
-      #valid CSDL
-      stub_request(:post, /api.datasift.com\/.*\/validate/).
-          with(:body => {"csdl" => @data.valid_csdl}).
-          to_return(:status  => @statuses.valid,
-                    :body    => fixture('validate_csdl_valid.json'),
-                    :headers => @headers.csdl_compile)
-      #invalid CSDL
-      stub_request(:post, /api.datasift.com\/.*\/validate/).
-          with(:body => {"csdl" => @data.invalid_csdl}).
-          to_return(:status  => @statuses.bad_request,
-                    :body    => fixture('validate_csdl_invalid.json'),
-                    :headers => @headers.csdl_compile)
-      #valid stream compilation
-      stub_request(:post, /api.datasift.com\/.*\/compile/).
-          with(:body => {"csdl" => @data.valid_csdl}).
-          to_return(:status  => @statuses.valid,
-                    :body    => fixture('compile_csdl_valid.json'),
-                    :headers => @headers.csdl_compile)
-    end
-
-    it 'test_csdl_cant_be_nil_when_validating' do
+  ##
+  # /validate
+  #
+  describe '#validate' do
+    it 'csdl_cant_be_nil_when_validating' do
       assert_raises InvalidParamError do
         @datasift.valid?(nil)
       end
     end
 
-    it 'test_csdl_cant_be_empty_when_validating' do
+    it 'csdl_cant_be_empty_when_validating' do
       assert_raises InvalidParamError do
         @datasift.valid?('')
       end
     end
 
-    it 'test_if_user_can_get_successful_validation_as_bool' do
-      assert @datasift.valid?(@data.valid_csdl), 'Valid CSDL must return true'
+    it 'user_can_get_successful_validation_as_bool' do
+      VCR.use_cassette('core/validate_success_bool') do
+        assert @datasift.valid?(@data.valid_csdl), 'Valid CSDL must return true'
+      end
     end
 
-    it 'test_if_user_can_get_successful_validation_as_hash' do
-      validation = @datasift.valid?(@data.valid_csdl, false)
-      assert_kind_of Hash, validation, 'Valid should return a hash here'
-      assert_equal @statuses.valid, validation[:http][:status], "This request should have returned status as #{@statuses.validate_csdl}"
+    it 'user_can_get_successful_validation_as_hash' do
+      VCR.use_cassette('core/validate_success_hash') do
+        validation = @datasift.valid?(@data.valid_csdl, false)
+        assert_kind_of Hash, validation,
+          "Successful validation will return a hash"
+        assert_equal STATUS.valid, validation[:http][:status],
+          "This request should have returned #{STATUS.valid} status"
+      end
     end
 
-    it 'test_failing_csdl_validation' do
-      assert_raises BadRequestError do
-        @datasift.valid?(@data.invalid_csdl)
+    it 'failing_csdl_validation' do
+      VCR.use_cassette('core/validate_invalid_hash') do
+        assert_raises BadRequestError do
+          @datasift.valid?(@data.invalid_csdl)
+        end
       end
     end
+  end
 
-    it 'test_csdl_cant_be_nil_when_compiling' do
+  ##
+  # /compile
+  #
+  describe '#compile' do
+    it 'csdl_cant_be_nil_when_compiling' do
       assert_raises InvalidParamError do
         @datasift.compile(nil)
       end
     end
 
-    it 'test_csdl_cant_be_empty_when_compiling' do
+    it 'csdl_cant_be_empty_when_compiling' do
       assert_raises InvalidParamError do
         @datasift.compile('')
       end
     end
-  end
-
-  describe '#usage' do
-    describe 'with valid request' do
-      before do
-        @headers.valid_usage = {
-            "date"              => "Thu, 30 Jan 2014 10:09:19 GMT", "content-type" => "application/json",
-            "transfer-encoding" => "chunked", "connection" => "close", "x-api-version" => "1",
-            "x-ratelimit-limit" => "10000", "x-ratelimit-remaining" => "10000", "x-ratelimit-cost" => "25"}
 
-        #valid /usage request
-        stub_request(:post, /api.datasift.com\/.*\/usage/).
-            with(:body => {:period => 'hour'}).
-            to_return(status:  @statuses.valid,
-                      body:    fixture('usage_current.json'),
-                      headers: @headers.valid_usage)
+    it 'successful_compilation_returns_hash' do
+      VCR.use_cassette('core/compile_success') do
+        response = @datasift.compile @data.valid_csdl
+        assert_kind_of Hash, response,
+          "Successful compilation will return a hash"
+        assert_equal STATUS.valid, response[:http][:status],
+          "This request should have returned #{STATUS.valid} status"
       end
+    end
+  end
 
-      it 'can get users usage' do
-        @datasift.usage
-        assert_requested(:post, "https://api.datasift.com/v1/usage", :body => {"period"=>"hour"})
+  ##
+  # /usage
+  #
+  describe '#usage' do
+    it 'can_get_users_usage' do
+      VCR.use_cassette('core/usage_success') do
+        response = @datasift.usage
+        assert_equal STATUS.valid, response[:http][:status]
+        assert_kind_of Hash, response
       end
     end
   end
 
+  ##
+  # /dpu
+  #
   describe '#dpu' do
     before do
-      @data.dpu_hash_valid = '145ea24a4d83a14ecb9077b831f14809'
-      @headers.dpu = {
-          "date"              => "Thu, 30 Jan 2014 10:09:19 GMT", "content-type" => "application/json",
-          "transfer-encoding" => "chunked", "connection" => "close", "x-api-version" => "1",
-          "x-ratelimit-limit" => "10000", "x-ratelimit-remaining" => "10000", "x-ratelimit-cost" => "5"}
+      VCR.use_cassette('core/before_dpu') do
+        @hash = @datasift.compile(@data.valid_csdl)[:data][:hash]
+      end
+    end
 
-      #valid /dpu request
-      stub_request(:post, /api.datasift.com\/.*\/dpu/).
-          with(:body => {:hash => @data.dpu_hash_valid}).
-          to_return(status:  @statuses.valid,
-                    body:    fixture('dpu_valid.json'),
-                    headers: @headers.dpu)
+    it 'can_get_dpu_cost' do
+      VCR.use_cassette('core/dpu_get_cost') do
+        response = @datasift.dpu @hash
+        assert_equal STATUS.valid, response[:http][:status]
+      end
+    end
+
+    it 'cannot_get_dpu_cost_for_invalid_hash' do
+      VCR.use_cassette('core/dpu_throw_badrequest') do
+        assert_raises BadRequestError do
+          @datasift.dpu @data.invalid_hash
+        end
+      end
     end
 
-    it 'can get dpu cost for valid stream' do
-      @datasift.dpu(@data.dpu_hash_valid)
-      assert_requested(:post, "https://api.datasift.com/v1/dpu", body: {hash: @data.dpu_hash_valid})
+    it 'requires_at_least_one_param' do
+      assert_raises ArgumentError do
+        @datasift.dpu
+      end
     end
   end
 
-  describe '#balance' do
+  describe '#dpu for Historics' do
     before do
-      @headers.balance = {
-          "date"              => "Thu, 30 Jan 2014 10:09:19 GMT", "content-type" => "application/json",
-          "transfer-encoding" => "chunked", "connection" => "close", "x-api-version" => "1",
-          "x-ratelimit-limit" => "10000", "x-ratelimit-remaining" => "10000", "x-ratelimit-cost" => "25"}
+      VCR.use_cassette('core/before_historic_dpu') do
+        @hash = @datasift.compile(@data.valid_csdl)[:data][:hash]
+        @historic = @datasift.historics.prepare(
+          @hash,
+          Time.now.to_i - 10800,
+          Time.now.to_i - 7200,
+          'Ruby test suite',
+          'tumblr',
+          10
+        )
+      end
+    end
 
-      #valid /dpu request
-      stub_request(:post, /api.datasift.com\/.*\/balance/).
-          to_return(status:  @statuses.valid,
-                    body:    fixture('balance.json'),
-                    headers: @headers.balance)
+    after do
+      VCR.use_cassette('core/after_historic_dpu') do
+        @datasift.historics.delete @historic[:data][:id]
+      end
     end
 
-    it 'can get account balance' do
-      @datasift.balance
-      assert_requested(:post, "https://api.datasift.com/v1/balance")
+    it 'can_get_dpu_cost_for_historic' do
+      VCR.use_cassette('core/historic_dpu') do
+        response = @datasift.dpu('', @historic[:data][:id])
+        assert_equal STATUS.valid, response[:http][:status]
+      end
     end
   end
 
+  ##
+  # /balance
+  #
+  describe '#balance' do
+    it 'can get account balance' do
+      VCR.use_cassette('core/balance_get') do
+        response = @datasift.balance
+        assert_equal STATUS.valid, response[:http][:status]
+      end
+    end
+  end
 end

data/test/datasift/historics_preview_api_test.rb

@@ -1,83 +1,52 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 describe 'DataSift::HistoricsPreview' do
-
   before do
     auth      = DataSiftExample.new
     @datasift = auth.datasift
     @data     = OpenStruct.new
-    @statuses = OpenStruct.new
-    @headers  = OpenStruct.new
 
-    @statuses.valid     = 200
-    @statuses.accepted  = 202
+    @data.valid_csdl = 'interaction.content contains "ruby"'
+    @data.sources = 'facebook,twitter'
+    @data.parameters = 'language.tag,freqDist,5;interaction.id,targetVol,hour'
+    @data.start = '1398898800'
+    @data.end = '1398985200'
   end
 
+  ##
+  # /preview/create
+  #
   describe '#create' do
     before do
-      @data.stream_hash = '145ea24a4d83a14ecb9077b831f14809'
-      @data.sources     = 'facebook,twitter'
-      @data.parameters  = 'language.tag,freqDist,5;interaction.id,targetVol,hour'
-      @data.start       = '1398898800'
-      @data.end         = '1398985200'
-
-      @headers.preview_create = {
-            "date"              => "Thu, 30 Jan 2014 10:09:19 GMT", "content-type" => "application/json",
-            "transfer-encoding" => "chunked", "connection" => "close", "x-api-version" => "1",
-            "x-ratelimit-limit" => "10000", "x-ratelimit-remaining" => "10000", "x-ratelimit-cost" => "25"}
-
-      #valid /preview/create request
-      stub_request(:post, /api.datasift.com\/.*\/preview\/create/).
-          with(:body => { :hash       => @data.stream_hash,
-                          :sources    => @data.sources,
-                          :parameters => @data.parameters,
-                          :start      => @data.start,
-                          :end        => @data.end}).
-          to_return(status:  @statuses.valid,
-                    body:    fixture('preview_create_valid.json'),
-                    headers: @headers.preview_create)
+      VCR.use_cassette('preview/before_preview_create') do
+        @hash = @datasift.compile(@data.valid_csdl)[:data][:hash]
+      end
     end
 
-    it 'can create an Historics Preview' do
-      @datasift.historics_preview.create(@data.stream_hash, @data.sources, @data.parameters, @data.start, @data.end)
-      assert_requested( :post,
-                        'https://api.datasift.com/v1/preview/create',
-                        :body => {:start      => @data.start,
-                                  :end        => @data.end,
-                                  :hash       => @data.stream_hash,
-                                  :sources    => @data.sources,
-                                  :parameters => @data.parameters})
+    it 'can_create_historics_preview' do
+      VCR.use_cassette('preview/preview_create_success') do
+        response = @datasift.historics_preview.create(@hash, @data.sources, @data.parameters, @data.start, @data.end)
+        assert_equal STATUS.accepted, response[:http][:status]
+      end
     end
-
   end
 
+  ##
+  # /preview/get
+  #
   describe '#get' do
     before do
-      @data.id = 'fbd5441ab17a46f2ac200f8cab6bdb79fe8efb31'
-
-      @headers.preview_get = {
-            "date"              => "Thu, 30 Jan 2014 10:09:19 GMT", "content-type" => "application/json",
-            "transfer-encoding" => "chunked", "connection" => "close", "x-api-version" => "1",
-            "x-ratelimit-limit" => "10000", "x-ratelimit-remaining" => "10000", "x-ratelimit-cost" => "5"}
-
-      #valid /preview/get running request
-      stub_request(:post, /api.datasift.com\/.*\/preview\/get/).
-          with(:body => { :id => @data.id}).
-          to_return(status:  @statuses.accepted,
-                    body:    fixture('preview_get_running.json'),
-                    headers: @headers.preview_get)
-
-      #valid /preview/get succeeded request
-      stub_request(:post, /api.datasift.com\/.*\/preview\/get/).
-          with(:body => { :id => @data.id}).
-          to_return(status:  @statuses.valid,
-                    body:    fixture('preview_get_succeeded.json'),
-                    headers: @headers.preview_get)
+      VCR.use_cassette('preview/before_preview_get') do
+        @hash = @datasift.compile(@data.valid_csdl)[:data][:hash]
+        @preview = @datasift.historics_preview.create(@hash, @data.sources, @data.parameters, @data.start, @data.end)
+      end
     end
 
     it 'can get an Historics Preview' do
-      @datasift.historics_preview.get(@data.id)
-      assert_requested( :post, 'https://api.datasift.com/v1/preview/get', :body => {:id => @data.id})
+      VCR.use_cassette('preview/preview_get_success') do
+        response = @datasift.historics_preview.get(@preview[:data][:id])
+        assert_equal STATUS.accepted, response[:http][:status]
+      end
     end
   end
 end