aws_cloud_search 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--drb

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in aws_cloud_search.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+LICENSE
+
+The MIT License
+
+Copyright (c) 2012 Spoke Software, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# AWSCloudSearch
+
+## Description
+
+This gem is an implementation of the Amazon Web Service CloudSearch API (http://aws.amazon.com/cloudsearch/).
+
+The AWS CloudSearch service is comprised of three API end points: search, document batching, and configuration. This gem
+currently supports only the search and document batching APIs
+
+## Roadmap
+
+Spoke developed this library in a short period of time in order to migrate from IndexTank to AWS CloudSearch.
+As such, there are a few features that are missing that we would like to build over time.
+
++ Implementation of the configuration API
++ Query builder
++ Faceting helpers
++ Spec tests that stub the AWS CloudSearch service
++ Sample usage in this README
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'aws_cloud_search'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install aws_cloud_search
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')

data/aws_cloud_search.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/aws_cloud_search/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["David Jensen", "Mike Javorski"]
+  gem.email         = ["david.jensen@spoke.com", "mike.javorski@spoke.com"]
+  gem.description   = %q{AWSCloudSearch Search gem}
+  gem.summary       = %q{Implementation of the AWS CloudSearch API}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "aws_cloud_search"
+  gem.require_paths = ["lib"]
+  gem.version       = AWSCloudSearch::VERSION
+
+  gem.add_dependency 'faraday_middleware', '>= 0.8.0'
+
+  gem.add_development_dependency 'rspec', '>= 2.6.0'
+end

data/lib/aws_cloud_search.rb

@@ -0,0 +1,79 @@
+require "aws_cloud_search/cloud_search"
+require "aws_cloud_search/cloud_search_config"
+require "aws_cloud_search/document"
+require "aws_cloud_search/document_batch"
+require "aws_cloud_search/document_batcher"
+require "aws_cloud_search/exceptions"
+require "aws_cloud_search/search_response"
+require "aws_cloud_search/search_request"
+require "aws_cloud_search/version"
+
+require "faraday_middleware"
+
+module AWSCloudSearch
+  API_VERSION = "2011-02-01"
+
+  # AWS CloudSearch only allows XML 1.0 valid characters
+  INVALID_CHAR_XML10 = /[^\u0009\u000a\u000d\u0020-\uD7FF\uE000-\uFFFD]/m
+  # for future reference in case AWS-CS updates to XML 1.1 char compliance
+  #INVALID_CHAR_XML11 = /[^\u0001-\uD7FF\uE000-\uFFFD]/m
+
+
+  def self.search_url(domain, region="us-east-1")
+    "http://search-#{domain}.#{region}.cloudsearch.amazonaws.com"
+  end
+
+  def self.document_url(domain, region="us-east-1")
+    "http://doc-#{domain}.#{region}.cloudsearch.amazonaws.com"
+  end
+
+  def self.configuration_url
+    "https://cloudsearch.us-east-1.amazonaws.com"
+  end
+
+  # Initialize the module
+  # @param [String] url
+  # @param [String] aws_access_key_id
+  # @param [String] aws_secret_access_key
+  def self.create_connection(url, aws_access_key_id=nil, aws_secret_access_key=nil)
+    connection = Faraday.new url do |builder|
+      builder.use AWSCloudSearch::HttpCodeResponseMiddleware
+      builder.use FaradayMiddleware::EncodeJson
+      builder.use FaradayMiddleware::ParseJson
+      builder.adapter Faraday.default_adapter
+
+      # for future reference
+      #conn.request :json, :content_type => /\bjson$/
+      #conn.response :json, :content_type => /\bjson$/
+      #conn.adapter Faraday.default_adapter
+    end
+    connection.headers['User-Agent'] = "AWSCloudSearch-Ruby-Client/#{VERSION}"
+    connection
+  end
+
+  class HttpCodeResponseMiddleware < Faraday::Response::Middleware
+    def on_complete(env)
+      case env[:status]
+        when 200..299
+          nil
+        when 408
+          raise RequestTimeout, env[:body]
+        when 400..499
+          raise HttpClientError, env[:body]
+        when 509
+          raise BandwidthLimitExceeded, env[:body]
+        when 500..599
+          raise HttpServerError, env[:body]
+        else
+          raise UnexpectedHTTPException, env[:body]
+      end
+    end
+
+    def initialize(app)
+      super
+      @parser = nil
+    end
+  end
+
+
+end

data/lib/aws_cloud_search/cloud_search.rb

@@ -0,0 +1,71 @@
+require "json"
+require "aws_cloud_search"
+
+module AWSCloudSearch
+  class CloudSearch
+
+    def initialize(domain, region="us-east-1")
+      @doc_conn = AWSCloudSearch::create_connection( AWSCloudSearch::document_url(domain, region) )
+      @search_conn = AWSCloudSearch::create_connection( AWSCloudSearch::search_url(domain, region) )
+    end
+
+    # Sends a batch of document updates and deletes by invoking the CloudSearch documents/batch API
+    # @param [DocumentBatch] doc_batch The batch of document adds and deletes to send
+    # @return
+    def documents_batch(doc_batch)
+      raise ArgumentError.new("Invalid argument. Expected DocumentBatch, got #{doc_batch.class}.") unless doc_batch.is_a? DocumentBatch
+
+      resp = @doc_conn.post do |req|
+        req.url "/#{AWSCloudSearch::API_VERSION}/documents/batch"
+        req.headers['Content-Type'] = 'application/json'
+        req.body = doc_batch.to_json
+      end
+      raise(Exception, "AwsCloudSearchCloud::DocumentService batch returned #{resp.body[:errors].size} errors: #{resp.body[:errors].join(';')}") if resp.body[:status] == 'error'
+      resp.body
+    end
+
+    # Performs a search
+    # @param [SearchRequest] search_req
+    # @return
+    def search(search_req)
+      raise ArgumentError.new("Invalid Type: search_request must be of type SearchRequest") unless search_req.is_a? SearchRequest
+
+      resp = @search_conn.get do |req|
+        req.url "/#{AWSCloudSearch::API_VERSION}/search", search_req.to_hash
+      end
+
+      search_response = SearchResponse.new(resp.body)
+      if search_response.error
+        raise StandardError.new("Unknown error") if resp.messages.blank?
+        code = resp.messages.first['code']
+        message = resp.messages.first['message']
+        msg = "#{code}: #{message}"
+        case code
+          when /WildcardTermLimit/
+            raise WildcardTermLimit.new(msg)
+          when /InvalidFieldOrRankAliasInRankParameter/
+            raise InvalidFieldOrRankAliasInRankParameter, msg
+          when /UnknownFieldInMatchExpression/
+            raise UnknownFieldInMatchExpression, msg
+          when /IncorrectFieldTypeInMatchExpression/
+            raise IncorrectFieldTypeInMatchExpression, msg
+          when /InvalidMatchExpression/
+            raise InvalidMatchExpression, msg
+          when /UndefinedField/
+            raise UndefinedField, msg
+          else
+            raise AwsCloudSearchError, "Unknown error. #{msg}"
+        end
+      end
+
+      search_response
+    end
+
+    # Build a DocumentBatcher linked to this CloudSearch domain
+    # @return [DocumentBatcher]
+    def new_batcher
+      DocumentBatcher.new(self)
+    end
+
+  end
+end

data/lib/aws_cloud_search/cloud_search_config.rb

@@ -0,0 +1,5 @@
+module AWSCloudSearch
+  class CloudSearchConfig
+
+  end
+end

data/lib/aws_cloud_search/document.rb

@@ -0,0 +1,81 @@
+require "json"
+
+module AWSCloudSearch
+  class Document
+
+    # A typed attribute accessor helper. When the value is set, if it does not match
+    # the pre-defined type, an exception is thrown.
+    # @param [String] name Name of the attribute
+    # @param [Class] type The class type of the attribute
+    def self.type_attr_accessor(name, type)
+      define_method(name) do
+        instance_variable_get("@#{name}")
+      end
+
+      define_method("#{name}=") do |value|
+        if value.is_a? type or value == nil
+          instance_variable_set("@#{name}", value)
+        else
+          raise ArgumentError.new("Invalid Type")
+        end
+      end
+    end
+
+    type_attr_accessor :version, Integer
+    type_attr_accessor :lang, String
+    attr_accessor :type
+    attr_reader :fields, :id
+
+    # Initializes the object
+    # @param [boolean] auto_version Set to true to automatically set the version, default is false
+    def initialize(auto_version=false)
+      @fields = {}
+      new_version if auto_version
+    end
+
+    # Adds a new field to the document
+    # @param [String] name Name of the document field
+    # @param [String, Integer] value Value of the document field
+    def add_field(name, value)
+      raise ArgumentError.new("Found invalid XML 1.0 unicode character(s)") if value.is_a? String and value =~ INVALID_CHAR_XML10
+      @fields[name] = value
+    end
+
+    # The id field must conform to a special format
+    def id=(id)
+      raise ArgumentError.new("Invalid ID: Document id must be a String or respond to #to_s") if (id.nil? || !id.respond_to?(:to_s))
+      @id = id.to_s
+      raise ArgumentError.new("Invalid ID: Document id must match the regex [a-z0-9][a-z0-9_]*$") unless @id =~ /^[a-z0-9][a-z0-9_]*$/
+    end
+
+    # Resets the fields.
+    def clear_fields
+      @fields = {}
+    end
+
+    # Set a new version automatically
+    def new_version
+      @version = Time.now.to_i
+    end
+
+    # Return this object as a hash
+    def to_hash
+      @fields.delete_if {|key,val| val.nil?}
+      h = {
+          :type => @type,
+          :id => @id,
+          :version => @version,
+          :fields => @fields
+      }
+      h[:lang] = @lang unless (@type == 'delete')
+
+      h      
+    end
+
+    #Return this object as json
+    def to_json
+      to_hash.to_json
+    end
+
+  end
+end

data/lib/aws_cloud_search/document_batch.rb

@@ -0,0 +1,81 @@
+require "json"
+require "aws_cloud_search"
+
+module AWSCloudSearch
+  class DocumentBatch
+
+    attr_reader :bytesize
+
+    # Constructor
+    # @param [Integer] pref_bytesize The preferred size of the batch in bytes. May be exceeded, if so batch is considered full.
+    # @param [Integer] max_bytesize The batch size in bytes must not exceed this number. Must be greater than pref_bytesize.
+    # @raise [ArgumentError] If pref_bytesize is not less than max_bytesize
+    def initialize(pref_bytesize=1048576, max_bytesize= 5242880)
+      raise ArgumentError.new("pref_bytesize must be less than max_bytesize") if pref_bytesize >= max_bytesize
+
+      @pref_bytesize = pref_bytesize
+      @max_bytesize = max_bytesize
+      @batch_add = []
+      @batch_delete = []
+      @bytesize = 0
+    end
+
+    # Adds a document with the add operation to the batch.
+    # @param [Document] doc
+    # @raise [ArgumentError] If parameter is not an AWSCloudSearch::Document
+    def add_document(doc)
+      raise ArgumentError.new("Invalid Type") unless doc.is_a? Document
+
+      doc.type = 'add'
+      json = doc.to_json
+      doc_bytesize = json.bytesize
+
+      raise Exception.new("Max batch size exceeded, document add was not added to batch.") if (doc_bytesize + @bytesize) > @max_bytesize
+      raise ArgumentError.new("Found invalid XML 1.0 unicode characters.") if json =~ INVALID_CHAR_XML10
+
+      @bytesize += doc_bytesize
+      @batch_add << doc
+    end
+
+    # Adds a delete document operation to the batch. Removes lang and fields from the object as they are not
+    # required for delete operations.
+    # @param [Document] doc The document to delete
+    # @raise [ArgumentError] If parameter is not an AWSCloudSearch::Document
+    # TODO: refactor to only use the required fields, hide the document construction from the user
+    def delete_document(doc)
+      raise ArgumentError.new("Invalid Type") unless doc.is_a? Document
+
+      doc.type = 'delete'
+      doc.lang = nil
+      doc.clear_fields
+      doc_bytesize = doc.to_json.bytesize
+
+      raise Exception.new("Max batch size exceeded, document delete was not added to batch.") if (doc_bytesize + @bytesize) > @max_bytesize
+
+      @bytesize += doc_bytesize
+      @batch_delete << doc
+    end
+
+    # @return [Integer] Number of items in the batch
+    def size
+      @batch_add.size + @batch_delete.size
+    end
+
+    # @return [Boolean] True if the bytesize of the batch exceeds the preferred bytesize
+    def full?
+      @bytesize >= @pref_bytesize
+    end
+
+    # @return [String] The JSON string representation of the DocumentBatch
+    def to_json
+      (@batch_add + @batch_delete).map {|item| item.to_hash}.to_json
+    end
+
+    def clear
+      @batch_add.clear
+      @batch_delete.clear
+      @bytesize = 0
+    end
+
+  end
+end

data/lib/aws_cloud_search/document_batcher.rb

@@ -0,0 +1,35 @@
+require "json"
+require "aws_cloud_search"
+
+module AWSCloudSearch
+  # Convenience method that will allow continuous batch additions and will chunk to a size threshold
+  # and send requests for each chunk.
+  class DocumentBatcher
+
+    def initialize(cs)
+      @cs = cs
+      @batch = DocumentBatch.new
+    end
+
+    def add_document(doc)
+      flush if @batch.full?
+
+      @batch.add_document doc
+    end
+
+    def delete_document(doc)
+      flush if @batch.full?
+
+      @batch.delete_document doc
+    end
+
+    # Sends the batch of adds and deletes to CloudSearch Search and then clears the current batch.
+    # TODO: (dj) implement connection retry logic
+    def flush
+      @cs.documents_batch @batch
+      @batch.clear
+    end
+
+  end
+
+end

data/lib/aws_cloud_search/exceptions.rb

@@ -0,0 +1,17 @@
+module AWSCloudSearch
+  # CloudSearch API errors
+  class AwsCloudSearchError < StandardError; end
+  class WildcardTermLimit < AwsCloudSearchError; end
+  class InvalidFieldOrRankAliasInRankParameter < AwsCloudSearchError; end
+  class UnknownFieldInMatchExpression < AwsCloudSearchError; end
+  class IncorrectFieldTypeInMatchExpression < AwsCloudSearchError; end
+  class InvalidMatchExpression < AwsCloudSearchError; end
+  class UndefinedField < AwsCloudSearchError; end
+
+  # HTTP errors
+  class UnexpectedHTTPException < StandardError; end
+  class HttpClientError < StandardError; end
+  class HttpServerError < StandardError; end
+  class RequestTimeout < HttpClientError; end
+  class BandwidthLimitExceeded < HttpServerError; end
+end

data/lib/aws_cloud_search/search_request.rb

@@ -0,0 +1,19 @@
+module AWSCloudSearch
+  class SearchRequest
+
+    attr_accessor :q, :bq, :rank, :results_type, :return_fields, :size, :start
+
+    def to_hash
+      hash = {}
+      hash['q']     = @q unless @q.nil?
+      hash['bq']    = @bq unless @bq.nil?
+      hash['rank']  = @rank unless @rank.nil?
+      hash['size']  = @size unless @size.nil?
+      hash['start'] = @start unless @start.nil?
+      hash['results-type']  = @results_type unless @results_type.nil?
+      hash['return-fields'] = @return_fields.join(',') unless @return_fields.nil?
+      hash
+    end
+
+  end
+end

data/lib/aws_cloud_search/search_response.rb

@@ -0,0 +1,37 @@
+module AWSCloudSearch
+  class SearchResponse
+    attr_reader :response
+    attr_reader :hits
+
+    alias :results :hits
+
+    # error is an undocumented field that occurs when an error is returned
+    FIELDS = [ :match_expr, :rank, :cpu_time_ms, :time_ms, :rid, :found, :start, :error, :messages ].freeze
+    FIELDS.each { |f| attr_accessor f }
+
+    # Takes in the hash, representing the json object returned from a search request
+    def initialize(response)
+      @response = response
+
+      FIELDS.each do |f|
+        fs = f.to_s.gsub('_' , '-')
+        if @response.has_key? 'info' and @response['info'][fs]
+          val = @response['info'][fs]
+        elsif @response.has_key? 'hits' and @response['hits'][fs]
+          val = @response['hits'][fs]
+        else
+          val = @response[fs]
+        end
+        self.instance_variable_set "@#{f}", val unless val.nil?
+      end
+
+      @hits = @response['hits']['hit'] if @response.has_key? 'hits'
+    end
+
+    def result_size
+      @hits ? @hits.size : 0
+    end
+
+
+  end
+end

data/lib/aws_cloud_search/version.rb

@@ -0,0 +1,3 @@
+module AWSCloudSearch
+  VERSION = "0.0.1"
+end

data/spec/aws_cloud_search/cloud_search_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+# These tests requires that your domain index contains the following fields:
+# - name: text
+# - type: text
+# - summary: text
+# - num_links: uint
+describe AWSCloudSearch::CloudSearch do
+
+  let(:ds) { AWSCloudSearch::CloudSearch.new(ENV['CLOUDSEARCH_DOMAIN']) }
+
+  it "should send document batch" do
+    batch = AWSCloudSearch::DocumentBatch.new
+    
+    doc1 = AWSCloudSearch::Document.new(true)
+    doc1.id = Array.new( 8 ) { rand(256) }.pack('C*').unpack('H*').first
+    doc1.lang = 'en'
+    doc1.add_field('name', 'Jane Williams')
+    doc1.add_field('type', 'person')
+
+    doc2 = AWSCloudSearch::Document.new(true)
+    doc2.id = Array.new( 8 ) { rand(256) }.pack('C*').unpack('H*').first
+    doc2.lang = 'en'
+    doc2.add_field :name, 'Bob Dobalina'
+    doc2.add_field :type, 'person'
+
+    batch.add_document doc1
+    batch.add_document doc2
+    ds.documents_batch(batch)
+  end
+
+  it "should delete a document" do
+    id = 'joeblotzdelete_test'
+    batch1 = AWSCloudSearch::DocumentBatch.new
+    doc1 = AWSCloudSearch::Document.new(true)
+    doc1.id = id
+    doc1.lang = 'en'
+    doc1.add_field('name', 'Joe Blotz Delete Test')
+    doc1.add_field('type', 'person')
+    batch1.add_document doc1
+    ds.documents_batch(batch1)
+
+    batch2 = AWSCloudSearch::DocumentBatch.new
+    doc2 = AWSCloudSearch::Document.new(true)
+    doc2.id = id
+    batch2.delete_document doc2
+    ds.documents_batch(batch2)
+  end
+
+  it "should raise ArgumentError for invalid XML 1.0 chars" do
+    batch = AWSCloudSearch::DocumentBatch.new
+
+    doc1 = AWSCloudSearch::Document.new(true)
+    id = Time.now.to_i.to_s
+    doc1.id = id
+    doc1.lang = 'en'
+    doc1.add_field('name', "Jane Williams")
+    doc1.add_field('type', 'person')
+
+    # \\uD800 is not a valid UTF-8 and it this line of code may cause your debugger to break
+    expect {doc1.add_field("summary", "This is a REALLY bad char, not even UTF-8 acceptable: \uD800")}.to raise_error(ArgumentError)
+
+    #expect { batch.add_document doc1 }.to raise_error(ArgumentError)
+
+    doc2 = AWSCloudSearch::Document.new(true)
+    id = Time.now.to_i.to_s
+    doc2.id = id
+    doc2.lang = 'en'
+    doc2.add_field('name', "Brian Williams")
+    doc2.add_field('type', 'person')
+    expect {doc2.add_field("summary", "This is a bad char for XML 1.0: \v")}.to raise_error(ArgumentError)
+
+    doc2.instance_variable_get("@fields")['how_did_i_get_here'] = "This is a bad char for XML 1.0: \ufffe"
+    expect { batch.add_document doc2 }.to raise_error(ArgumentError)
+
+  end
+
+
+
+  it "should return a DocumentBatcher instance for new_batcher" do
+    ds.new_batcher.should be_an(AWSCloudSearch::DocumentBatcher)
+  end
+
+  it "should search" do
+    sr = AWSCloudSearch::SearchRequest.new
+    sr.bq = "(and name:'Jane')"
+    sr.return_fields = %w(logo_url name type)
+    sr.size = 10
+    sr.start = 0
+    sr.results_type = 'json'
+
+    res = ds.search(sr)
+
+    res.should be_an(AWSCloudSearch::SearchResponse)
+  end
+
+end

data/spec/aws_cloud_search/document_batch_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe AWSCloudSearch::DocumentBatch do
+
+  let(:batch) { AWSCloudSearch::DocumentBatch.new }
+
+  let(:sample_add_doc) do
+    AWSCloudSearch::Document.new(true).tap do |d|
+      d.id = '73e'
+      d.lang = 'en'
+      d.add_field('name', 'Jane Williams')
+      d.add_field('type', 'person')
+    end
+  end
+
+  let(:sample_delete_doc) do
+    AWSCloudSearch::Document.new(true).tap do |d|
+      d.type = 'delete' # we have to set this here so that delete doc bytesize calculations are correct
+      d.id = '47p'
+      d.lang = nil
+    end
+  end
+
+  it "should should not instantiate" do
+    expect { AWSCloudSearch::DocumentBatch.new(100, 100) }.to raise_error(ArgumentError)
+    expect { AWSCloudSearch::DocumentBatch.new(101, 100) }.to raise_error(ArgumentError)
+  end
+
+  it "should instantiate" do
+    expect { AWSCloudSearch::DocumentBatch.new }.to_not raise_error
+    expect { AWSCloudSearch::DocumentBatch.new(100, 101) }.to_not raise_error
+  end
+
+  it "should raise error when passed an invalid object type" do
+    expect { batch.add_document("Hello") }.to raise_error(ArgumentError)
+    expect { batch.delete_document("Hello") }.to raise_error(ArgumentError)
+  end
+
+  it "should not raise error when passed a Document" do
+    expect { batch.add_document(sample_add_doc) }.to_not raise_error(ArgumentError)
+    expect { batch.delete_document(sample_delete_doc) }.to_not raise_error(ArgumentError)
+  end
+
+  it "should return the correct size" do
+    batch.add_document sample_add_doc
+    batch.size.should eq(1)
+
+    batch.delete_document sample_delete_doc
+    batch.size.should eq(2)
+  end
+
+  it "should raise error when the max batch size is exceeded" do
+    small_batch = AWSCloudSearch::DocumentBatch.new(1, 10)
+    expect { small_batch.add_document(sample_add_doc) }.to raise_error
+    expect { small_batch.delete_document(sample_delete_doc) }.to raise_error
+  end
+
+  it "should be full" do
+    bytesize = sample_add_doc.to_json.bytesize
+
+    b1 = AWSCloudSearch::DocumentBatch.new(bytesize)
+    b1.add_document sample_add_doc
+    b1.full?.should be_true
+
+    b2 = AWSCloudSearch::DocumentBatch.new(bytesize-1)
+    b2.add_document sample_add_doc
+    b2.full?.should be_true
+
+    bytesize = sample_delete_doc.to_json.bytesize
+
+    b3 = AWSCloudSearch::DocumentBatch.new(bytesize)
+    b3.delete_document sample_delete_doc
+    b3.full?.should be_true
+
+    b4 = AWSCloudSearch::DocumentBatch.new(bytesize-1)
+    b4.delete_document sample_delete_doc
+    b4.full?.should be_true
+  end
+
+  it "should return the total bytesize of all docs" do
+    batch.bytesize.should eq(0)
+
+    batch.add_document sample_add_doc
+    bytesize = sample_add_doc.to_json.bytesize
+    batch.bytesize.should eq(bytesize)
+
+    batch.delete_document sample_delete_doc
+    bytesize += sample_delete_doc.to_json.bytesize
+    batch.bytesize.should eq(bytesize)
+  end
+
+  it "should not be full" do
+    batch.add_document sample_add_doc
+    batch.full?.should_not be_true
+
+    batch.delete_document sample_add_doc
+    batch.full?.should_not be_true
+  end
+
+  it "should clear" do
+    clear_batch = AWSCloudSearch::DocumentBatch.new
+    clear_batch.add_document sample_add_doc
+    clear_batch.delete_document sample_delete_doc
+
+    clear_batch.bytesize.should be > 0
+    clear_batch.size.should be > 0
+
+    clear_batch.clear
+
+    clear_batch.bytesize.should eq(0)
+    clear_batch.size.should eq(0)
+  end
+
+end

data/spec/aws_cloud_search/document_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe AWSCloudSearch::Document do
+  let(:doc) { AWSCloudSearch::Document.new }
+
+  context "#id=" do
+    it "should accept a String-able value (Integer)" do
+      expect { doc.id = 123456789 }.to_not raise_error
+    end
+  
+    it "should accept a compliant String" do
+      expect { doc.id = "abcdef" }.to_not raise_error
+    end
+
+    it "should not accept a non-compliant String" do
+      expect { doc.id = 'AZ12' }.to raise_error(ArgumentError)
+      expect { doc.id = '!@#$%^&*()AZ' }.to raise_error(ArgumentError)
+      expect { doc.id = '_abc123' }.to raise_error(ArgumentError)
+    end
+
+    it "should not accept nil" do
+      expect { doc.id = nil }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "#type_attr_accessor attributes" do
+    it "should accept values of proper type" do
+      expect { doc.lang = 'abcd' }.to_not raise_error
+      expect { doc.version = 1234 }.to_not raise_error
+    end
+
+    it "should not accept values of incorrect type" do 
+      expect { doc.lang = 1234 }.to raise_error(ArgumentError)
+      expect { doc.version "abcd" }.to raise_error(ArgumentError)
+    end
+  end
+
+end

data/spec/aws_cloud_search/search_response_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe AWSCloudSearch::SearchResponse do
+  before(:each) do
+    @res1 = {
+        'hits' => {
+          'found' => 1,
+          'start' => 0,
+          'hit' => [
+            { 'id' => '2e'}
+          ]
+        },
+        'info' => {
+          'cpu-time-ms' => 0,
+          'time-ms' => 2,
+          'rid' => '6ddcaa561c05c4cc221cb551e21a9631b979b9aa5297fab17731a8b9f863b20423151ddcd9b246caee73334112c96801'
+        }
+    }
+  end
+
+  it "should initialize from hash" do
+    sr = AWSCloudSearch::SearchResponse.new(@res1)
+
+    sr.found.should eq(1)
+    sr.start.should eq(0)
+    sr.cpu_time_ms.should eq(0)
+    sr.time_ms.should eq(2)
+    sr.rid.should eq('6ddcaa561c05c4cc221cb551e21a9631b979b9aa5297fab17731a8b9f863b20423151ddcd9b246caee73334112c96801')
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'aws_cloud_search'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: aws_cloud_search
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- David Jensen
+- Mike Javorski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-18 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: &9414220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *9414220
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &9413280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *9413280
+description: AWSCloudSearch Search gem
+email:
+- david.jensen@spoke.com
+- mike.javorski@spoke.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- aws_cloud_search.gemspec
+- lib/aws_cloud_search.rb
+- lib/aws_cloud_search/cloud_search.rb
+- lib/aws_cloud_search/cloud_search_config.rb
+- lib/aws_cloud_search/document.rb
+- lib/aws_cloud_search/document_batch.rb
+- lib/aws_cloud_search/document_batcher.rb
+- lib/aws_cloud_search/exceptions.rb
+- lib/aws_cloud_search/search_request.rb
+- lib/aws_cloud_search/search_response.rb
+- lib/aws_cloud_search/version.rb
+- spec/aws_cloud_search/cloud_search_spec.rb
+- spec/aws_cloud_search/document_batch_spec.rb
+- spec/aws_cloud_search/document_spec.rb
+- spec/aws_cloud_search/search_response_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Implementation of the AWS CloudSearch API
+test_files:
+- spec/aws_cloud_search/cloud_search_spec.rb
+- spec/aws_cloud_search/document_batch_spec.rb
+- spec/aws_cloud_search/document_spec.rb
+- spec/aws_cloud_search/search_response_spec.rb
+- spec/spec_helper.rb