sumo-search 0.1.1 → 1.0.2

data/lib/sumo/config.rb

@@ -11,13 +11,10 @@ class Sumo::Config
 
   attr_reader :config_file
 
-  # Set and freeze the @config_file instance variable.
+  # Given an optional `String`, sets and freezes the `@config_file` instance
+  # variable, as long as it's a valid file path.
   def initialize(config_file = Sumo::DEFAULT_CONFIG_FILE)
-    if config_file.is_a?(String)
-      @config_file = File.expand_path(config_file).freeze
-    else
-      raise TypeError, "Expected a String, got: #{config_file}"
-    end
+    @config_file = File.expand_path(config_file).freeze
   end
 
   # Test if an alternate file has been specified.
@@ -25,19 +22,19 @@ class Sumo::Config
     config_file != Sumo::DEFAULT_CONFIG_FILE
   end
 
-  # Memoize the credentials from the environment.
+  # Get the credentials from the environment.
   def env_creds
-    @env_creds ||= ENV['SUMO_CREDS']
+    ENV['SUMO_CREDS']
   end
 
-  # Memoize the credentials from the configuration file.
+  # Get the credentials from the configuration file.
   def file_creds
-    @file_creds ||= File.read(config_file).chomp if File.exists?(config_file)
+    File.read(config_file).chomp if File.exists?(config_file)
   end
 
   # Load the credentials.
-  def load_config
-    if file_specified?
+  def load_creds
+    @config ||= if file_specified?
       file_creds || env_creds
     else
       env_creds || file_creds
@@ -45,8 +42,8 @@ class Sumo::Config
   end
 
   # Load the credentials, raising an error if none are specified.
-  def load_config!
-    if (creds = load_config).nil?
+  def load_creds!
+    if (creds = load_creds).nil?
       raise NoCredsFound, "No credentials were found, set ENV['SUMO_CREDS']."
     else
       creds

data/lib/sumo/error.rb

@@ -1,18 +1,15 @@
-# This module acts as a namespace for all errors thrown in the gem.
+# This module holds all errors for the gem.
 module Sumo::Error
-  # This error is never raised, but instead used to catch all other errors that
-  # may be raised.
+  # This class is never thrown but can be used to catch all errors thrown in the
+  # gem.
   class BaseError < StandardError; end
 
-  # Raised when an unexpected type is passed to a method.
-  class TypeError < BaseError; end
-
-  # This error is raised when no credentials can be found.
+  # This is raised when credentials cannot be found.
   class NoCredsFound < BaseError; end
 
-  # This error is raised when there is an error on a request.
-  class RequestError < BaseError; end
+  # Raised when a 4xx-level response is returned by the API.
+  class ClientError < BaseError; end
 
-  # This error is raised when a parsing error occurs.
-  class ParseError < BaseError; end
+  # Raised when a 5xx-level response is returned by the API.
+  class ServerError < BaseError; end
 end

data/lib/sumo/search.rb

@@ -0,0 +1,69 @@
+# This class represents a search job.
+class Sumo::Search
+  attr_reader :id, :client
+
+  # Create a new search job with the given query.
+  def self.create(params = {}, client = Sumo.client)
+    params[:timeZone] ||= params.delete(:time_zone) || params.delete(:tz)
+    result = client.post(:path => '/search/jobs', :body => params.to_json)
+    new(JSON.parse(result)['id'], client)
+  end
+
+  # Initialize a new `Sumo::Search` with the given `id` and `client`.
+  def initialize(id, client)
+    @id = id
+    @client = client
+  end
+  private_class_method :new
+
+  # Get the status of the search job.
+  def status
+    JSON.parse(client.get(:path => base_path))
+  end
+
+  # Cancel the search job.
+  def delete!
+    client.delete(:path => base_path)
+    nil
+  end
+
+  # Return an `Enumerator` containing each message found by the search.
+  def messages
+    @messages ||= Sumo::Collection.new(
+      :get_values => proc { |hash| self.get_messages(hash) },
+      :get_status => proc { self.status },
+      :count_key => 'messageCount'
+    ).each
+  end
+
+  # Return an `Enumerator` containing each record found by the search.
+  def records
+    @records ||= Sumo::Collection.new(
+      :get_values => proc { |hash| self.get_records(hash) },
+      :get_status => proc { self.status },
+      :count_key => 'recordCount'
+    ).each
+  end
+
+  # Get the messages from the given offset and limit.
+  def get_messages(query)
+    resp = client.get(:path => "#{base_path}/messages", :query => query)
+    extract_response('messages', resp)
+  end
+
+  # Get the records from the given offset and limit.
+  def get_records(query)
+    resp = client.get(:path => "#{base_path}/records", :query => query)
+    extract_response('records', resp)
+  end
+
+  def extract_response(key, resp)
+    JSON.parse(resp)[key].map { |hash| hash['map'] }
+  end
+  private :extract_response
+
+  def base_path
+    @base_path ||= "/search/jobs/#{id}"
+  end
+  private :base_path
+end

data/lib/sumo/version.rb

@@ -1,4 +1,11 @@
-# This file contains the version of the gem.
+# This module holds versioning information for the gem.
 module Sumo
-  VERSION = '0.1.1'
+  MAJOR = 1
+  MINOR = 0
+  PATCH = 2
+  RELEASE = nil
+
+  VERSION = [MAJOR, MINOR, PATCH, RELEASE].compact.join('.')
+
+  API_VERSION = 1
 end

data/lib/sumo.rb

@@ -1,28 +1,62 @@
 require 'base64'
+require 'clamp'
 require 'excon'
 require 'json'
 
-# This module acts as a namespace, and contains a `.search` method which ties
-# together functionality of its child modules.
+# This is the top level module for the gem. It is used as a namespace and holds
+# top-level convenience functions.
 module Sumo
-  autoload :Config, 'sumo/config'
-  autoload :Error, 'sumo/error'
-  autoload :Formatter, 'sumo/formatter'
-  autoload :QueryBuilder, 'sumo/query_builder'
-
-  # Unless otherwise specified in the initializer, the configuration file
-  # defaults to '~/.sumo_creds'.
+  # Define global constants.
   DEFAULT_CONFIG_FILE = File.expand_path('~/.sumo_creds').freeze
 
-  # Search the given query. If any options are supplied, those are sent to the
-  # QueryBuilder. If the key is supplied, that key will be attempted to be
-  # extracted from the JSON response. If a config_file is supplied, that will
-  # be read instead of the default.
-  def search(query, options: {}, key: nil, config_file: DEFAULT_CONFIG_FILE)
-    creds = Config.new(config_file).load_config!
-    response = QueryBuilder.new(creds, options.merge('q' => query)).execute
-    formatted = Formatter.format_json(response)
-    key.nil? ? formatted : Formatter.extract_key(key, formatted)
+  # Require sub-modules.
+  require 'sumo/error'
+  require 'sumo/config'
+  require 'sumo/client'
+  require 'sumo/search'
+  require 'sumo/collection'
+  require 'sumo/cli'
+  require 'sumo/version'
+
+  # Define top-level functions.
+
+  def creds
+    @creds ||= config.load_creds!
+  end
+  module_function :creds
+
+  def creds=(new_creds)
+    @creds = new_creds
+  end
+  module_function :creds=
+
+  # The default config for the gem.
+  def config
+    @config ||= Sumo::Config.new
+  end
+  module_function :config
+
+  # Reset the default config for the gem.
+  def config=(new_config)
+    @config = new_config
+  end
+  module_function :config=
+
+  # The default client for the gem.
+  def client
+    @client ||= Sumo::Client.new
+  end
+  module_function :client
+
+  # Reset the default client for the gem.
+  def client=(new_client)
+    @client = new_client
+  end
+  module_function :client=
+
+  # Create a new search.
+  def search(*args)
+    Sumo::Search.new(*args)
   end
   module_function :search
 end

data/spec/fixtures/sumo-creds

@@ -0,0 +1 @@
+test@test.net:trustno1

data/spec/lib/sumo/client_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe Sumo::Client do
+  describe '#initialize' do
+    let(:creds) { 'email@email.email:password' }
+
+    context 'with no arguments' do
+      subject { Sumo::Client.new }
+      before { Sumo.stub(:creds).and_return(creds) }
+      it 'sets the default credentials' do
+        subject.creds.should == creds
+      end
+    end
+
+    context 'with an argument' do
+      subject { Sumo::Client.new(creds) }
+
+      it 'sets the credentials to that argument' do
+        subject.creds.should == creds
+      end
+    end
+  end
+
+  describe '#request' do
+    let(:connection) { double(:connection) }
+    let(:response) { double(:response) }
+    let(:creds) { 'creds@email.com:test' }
+    let(:encoded) { Base64.encode64(creds).strip }
+    subject { Sumo::Client.new(creds) }
+    before { subject.stub(:connection).and_return(connection) }
+
+    it 'sets the correct headers' do
+      subject.stub(:handle_errors!)
+      response.stub(:body)
+      response.stub(:headers).and_return({})
+      connection.should_receive(:request)
+                .with(
+                  :method => :get,
+                  :path => '/api/v1/',
+                  :headers => {
+                    'Content-Type' => 'application/json',
+                    'Accept' => 'application/json',
+                    'Authorization' => "Basic #{encoded}" })
+                .and_return(response)
+      subject.request(:method => :get, :path => '/')
+    end
+
+    context 'when a 2xx-level status code is returned by the API' do
+      let(:body) { 'TEST RESULT' }
+      let(:cookie) { 'oreo' }
+      let(:headers) { {'Set-Cookie' => cookie } }
+      let(:response) {
+        double(:response, :status => 200, :body => body, :headers => headers)
+      }
+      before { connection.stub(:request).and_return(response) }
+
+      it 'returns the response body' do
+        subject.request(:method => :get, :path => '/').should == body
+      end
+
+      it 'sets the cookie' do
+        subject.request(:method => :get, :path => '/')
+        connection.should_receive(:request)
+                  .with(
+                    :method => :get,
+                    :path => '/api/v1/',
+                    :headers => {
+                      'Content-Type' => 'application/json',
+                      'Accept' => 'application/json',
+                      'Cookie' => cookie,
+                      'Authorization' => "Basic #{encoded}" })
+                  .and_return(response)
+        subject.request(:method => :get, :path => '/')
+      end
+    end
+
+    context 'when a 4xx-level status code is returned by the API' do
+      let(:response) { double(:response, :status => 400, :body => body) }
+      let(:body) { { 'message' => message }.to_json }
+      let(:message) { 'Client Error' }
+      before { connection.stub(:request).and_return(response) }
+
+      context 'when a message can be parsed out of the response' do
+        it 'raises a ClientError with that message' do
+          expect { subject.request(:method => :post, :path => '/') }
+            .to raise_error(Sumo::Error::ClientError, message)
+        end
+      end
+
+      context 'when a message cannot be parsed out of the response' do
+        let(:message) { nil }
+
+        it 'raises a ClientError with the default error message' do
+          expect { subject.request(:method => :delete, :path => '/') }
+            .to raise_error(Sumo::Error::ClientError,
+                            Sumo::Client::DEFAULT_ERROR_MESSAGE)
+        end
+      end
+    end
+
+    context 'when a 5xx-level status code is returned by the API' do
+      let(:response) { double(:response, :status => 500, :body => body) }
+      let(:body) { { 'message' => message }.to_json }
+      let(:message) { 'Server Error' }
+      before { connection.stub(:request).and_return(response) }
+
+      context 'when a message can be parsed out of the response' do
+        it 'raises a ServerError with that message' do
+          expect { subject.request(:method => :post, :path => '/') }
+            .to raise_error(Sumo::Error::ServerError, message)
+        end
+      end
+
+      context 'when a message cannot be parsed out of the response' do
+        let(:message) { nil }
+
+        it 'raises a ServerError with the default error message' do
+          expect { subject.request(:method => :delete, :path => '/') }
+            .to raise_error(Sumo::Error::ServerError,
+                            Sumo::Client::DEFAULT_ERROR_MESSAGE)
+        end
+      end
+    end
+  end
+
+  [:get, :post, :delete].each do |http_method|
+    describe "##{http_method}" do
+      subject { Sumo::Client.new('') }
+
+      it "sends a request where the HTTP method is #{http_method}" do
+        subject.should_receive(:request).with(:method => http_method)
+        subject.public_send(http_method, {})
+      end
+    end
+  end
+end

data/spec/lib/sumo/config_spec.rb

@@ -1,129 +1,110 @@
 require 'spec_helper'
 
 describe Sumo::Config do
-  describe '.new' do
-    subject { Sumo::Config }
+  let(:test_config_file) {
+    File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'sumo-creds')
+  }
 
-    context 'when no argument is given' do
-      it 'sets @config_file to its default value' do
-        subject.new.config_file.should == Sumo::DEFAULT_CONFIG_FILE
-      end
-    end
-
-    context 'when an argument is given' do
-      context 'when it is not a String' do
-        it 'raises an error' do
-          expect { subject.new(nil) }.to raise_error(Sumo::Error::TypeError)
-        end
-      end
+  describe '#initialize' do
+    let(:config_file) { '/etc/sumo-creds' }
+    subject { Sumo::Config.new(config_file) }
 
-      context 'when it is a String' do
-        let(:file) { '/dev/null' }
-
-        it 'sets @config_file to the argument' do
-          subject.new(file).config_file.should == file
-        end
-      end
+    it 'sets the @config_file instance variable' do
+      subject.config_file.should == config_file
     end
   end
 
   describe '#file_specified?' do
-    context 'when @config_file is the default' do
-      it 'returns false' do
-        subject.file_specified?.should be_false
-      end
-    end
-
-    context 'when @config_file is not the default' do
-      subject { Sumo::Config.new('my-config-file') }
+    context 'when Sumo::DEFAULT_CONFIG_FILE is not equal to @config_file' do
+      let(:config_file) { '/etc/sumo-creds' }
+      subject { Sumo::Config.new(config_file) }
 
       it 'returns true' do
         subject.file_specified?.should be_true
       end
     end
-  end
-
-  describe '#env_creds' do
-    before { ENV['SUMO_CREDS'] = creds }
 
-    context 'when the environment variable is not set' do
-      let(:creds) { nil }
+    context 'when Sumo::DEFAULT_CONFIG_FILE is equal to @config_file' do
+      subject { Sumo::Config.new }
 
-      it 'returns nil' do
-        subject.env_creds.should be_nil
+      it 'returns false' do
+        subject.file_specified?.should be_false
       end
     end
+  end
 
-    context 'when the environment variable is set' do
-      let(:creds) { 'alpha' }
+  describe '#env_creds' do
+    let(:email) { 'test@test.net' }
+    let(:password) { 'trustno1' }
+    let(:creds) { [email, password].join(':') }
 
-      it 'returns that variable' do
-        subject.env_creds.should == creds
-      end
+    before { ENV['SUMO_CREDS'] = creds }
+    after { ENV['SUMO_CREDS'] = nil }
+
+    it 'retrieves the $SUMO_CREDS environment variable' do
+      subject.env_creds.should == creds
     end
   end
 
   describe '#file_creds' do
-    subject { Sumo::Config.new(file) }
+    subject { Sumo::Config.new(config_file) }
 
-    context 'when the @config_file does not exist' do
-      let(:file) { 'not a file' }
+    context 'when @config_file is not a file' do
+      let(:config_file) { '/not/a/file' }
 
       it 'returns nil' do
         subject.file_creds.should be_nil
       end
     end
 
-    context 'when @config_file does exist' do
-      let(:file) { 'spec/fixtures/sumo_creds' }
+    context 'when @config_file is a file' do
+      let(:config_file) { test_config_file }
 
-      it 'returns its contents' do
-        subject.file_creds.should == 'fake_user@fake_site:fake_pass'
+      it 'returns the contents of that file' do
+        subject.file_creds.should == File.read(config_file).strip
       end
     end
   end
 
-  describe '#load_config' do
-    before do
-      subject.stub(:file_specified?).and_return(specified)
-      subject.stub(:file_creds).and_return('alpha')
-      subject.stub(:env_creds).and_return('beta')
-    end
+  describe '#load_creds' do
+    let(:email) { 'test@test.net' }
+    let(:password) { 'trustsum1' }
+    let(:creds) { [email, password].join(':') }
 
-    context 'when an alternate file is specifed' do
-      let(:specified) { true }
+    before { ENV['SUMO_CREDS'] = creds }
+    after { ENV['SUMO_CREDS'] = nil }
 
-      it 'attempts to read the file first' do
-        subject.load_config.should == 'alpha'
+    context 'when a config file is not specified' do
+      it 'prefers the environment variable' do
+        subject.load_creds.should == ENV['SUMO_CREDS']
       end
     end
 
-    context 'when an alternate file is not specified' do
-      let(:specified) { false }
+    context 'when a config file is specified' do
+      subject { Sumo::Config.new(test_config_file) }
 
-      it 'attempts to read the environment variable first' do
-        subject.load_config.should == 'beta'
+      it 'prefers the config file' do
+        subject.load_creds.should == File.read(test_config_file).strip
       end
     end
   end
 
-  describe 'load_config!' do
-    before { subject.stub(:load_config).and_return(config) }
-
-    context 'when #load_config returns nil' do
-      let(:config) { nil }
+  describe '#load_creds!' do
+    context 'when the configuration cannot be found' do
+      before { subject.stub(:load_creds).and_return(nil) }
 
       it 'raises an error' do
-        expect { subject.load_config! }
-            .to raise_error(Sumo::Error::NoCredsFound)
+        expect { subject.load_creds! }
+          .to raise_error(Sumo::Error::NoCredsFound)
       end
     end
 
-    context 'when #load_config returns a value' do
-      let(:config) { 'configuration' }
+    context 'when the configuration can be found' do
+      let(:creds) { 'sumo@sumo.net:my-pass' }
+      before { subject.stub(:load_creds).and_return(creds) }
 
-      it 'returns that value' do
-        subject.load_config!.should == config
+      it 'returns the configuration' do
+        subject.load_creds!.should == creds
       end
     end
   end