eden_cloud_search 0.1.10

data/lib/eden_cloud_search.rb

@@ -0,0 +1,24 @@
+# require "em-http"
+require "rest_client"
+require "json"
+require "eden_cloud_search/version"
+
+module CloudSearch
+  autoload :Config,                          "eden_cloud_search/config"
+  autoload :ConfigurationChecking,           "eden_cloud_search/config"
+  autoload :Searcher,                        "eden_cloud_search/searcher"
+  autoload :SearchResponse,                  "eden_cloud_search/search_response"
+  autoload :Indexer,                         "eden_cloud_search/indexer"
+  autoload :Document,                        "eden_cloud_search/document"
+  autoload :InvalidDocument,                 "eden_cloud_search/invalid_document"
+  autoload :InsufficientParametersException, "eden_cloud_search/exceptions"
+
+  def self.config
+    Config.instance
+  end
+
+  def self.configure(&block)
+    block.call(self.config)
+  end
+end
+

data/spec/cloud_search/config_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe CloudSearch::Config do
+  subject { CloudSearch::Config.instance }
+
+  before do
+    CloudSearch.configure do |config|
+      config.domain_id   = "pl6u4t3elu7dhsbwaqbsy3y6be"
+      config.domain_name = "imdb-movies"
+    end
+  end
+
+  describe "after set some configurations" do
+    it { expect(subject.api_version).to eql("2011-02-01") }
+    it { expect(subject.configuration_url).to eql("https://cloudsearch.us-east-1.amazonaws.com") }
+    it { expect(subject.domain_id).to eql("pl6u4t3elu7dhsbwaqbsy3y6be") }
+    it { expect(subject.domain_name).to eql("imdb-movies") }
+    it { expect(subject.document_url).to eql("http://doc-imdb-movies-pl6u4t3elu7dhsbwaqbsy3y6be.us-east-1.cloudsearch.amazonaws.com/2011-02-01") }
+    it { expect(subject.region).to eql("us-east-1") }
+    it { expect(subject.search_url).to eql("http://search-imdb-movies-pl6u4t3elu7dhsbwaqbsy3y6be.us-east-1.cloudsearch.amazonaws.com/2011-02-01") }
+  end
+end
+

data/spec/cloud_search/document_spec.rb

@@ -0,0 +1,335 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe CloudSearch::Document do
+  it "has a 'id' attribute" do
+    expect(described_class.new(:id => 123).id).to eq("123")
+  end
+
+  it "has a 'type' attribute" do
+    expect(described_class.new(:type => "add").type).to eq("add")
+  end
+
+  it "has a 'version' attribute" do
+    expect(described_class.new(:version => 1234).version).to eq(1234)
+  end
+
+  it "has a 'lang' attribute" do
+    expect(described_class.new(:lang => "en").lang).to eq("en")
+  end
+
+  it "has a 'fields' attribute" do
+    expect(described_class.new(:fields => {:foo => "bar"}).fields).to eq(:foo => "bar")
+  end
+
+  it "clears errors between validations" do
+    document = described_class.new :id => nil
+    expect(document).to_not be_valid
+    document.id = "123"
+    document.valid?
+    expect(document.errors[:id]).to be_nil
+  end
+
+  context "id validation" do
+    it "is invalid without an id" do
+      document = described_class.new
+      document.valid?
+      expect(document.errors[:id]).to eq(["can't be blank"])
+    end
+
+    %w(- ? A & * ç à @ % $ ! = +).each do |char|
+      it "is invalid containing #{char}" do
+        document = described_class.new :id => "1#{char}2"
+        document.valid?
+        expect(document.errors[:id]).to eq(["is invalid"])
+      end
+    end
+
+    it "is invalid starting with an '_'" do
+      document = described_class.new :id => "_abc"
+      document.valid?
+      expect(document.errors[:id]).to eq(["is invalid"])
+    end
+
+    it "is invalid with a string containing only spaces" do
+      document = described_class.new :id => " "
+      document.valid?
+      expect(document.errors[:id]).to eq(["can't be blank"])
+    end
+
+    it "is valid with a valid id" do
+      document = described_class.new :id => "507c54a44a42c408f4000001"
+      document.valid?
+      expect(document.errors[:id]).to be_nil
+    end
+
+    it "is valid with integers" do
+      document = described_class.new :id => 123
+      document.valid?
+      expect(document.errors[:id]).to be_nil
+    end
+
+    it "converts integers to strings" do
+      expect(described_class.new(:id => 123).id).to eq("123")
+    end
+  end
+
+  context "version validation" do
+    it "is invalid with a non numeric value" do
+      document = described_class.new :version => "123a3545656"
+      document.valid?
+      expect(document.errors[:version]).to eq(["is invalid"])
+    end
+
+    it "is invalid with a nil value" do
+      document = described_class.new :version => nil
+      document.valid?
+      expect(document.errors[:version]).to eq(["can't be blank"])
+    end
+
+    it "converts strings to integers" do
+      expect(described_class.new(:version => "123").version).to eq(123)
+    end
+
+    it "does not convert strings to integers if they contain non numerical characters" do
+      expect(described_class.new(:version => "123abc567").version).to eq("123abc567")
+    end
+
+    it "is invalid if value is greater than CloudSearch::Document::MAX_VERSION" do
+      document = described_class.new :version => 4294967296
+      document.valid?
+      expect(document.errors[:version]).to eq(["must be less than 4294967296"])
+    end
+
+    it "is valid with integers greater than zero and less or equal to CloudSearch::Document::MAX_VERSION" do
+      document = described_class.new :version => 4294967295
+      document.valid?
+      expect(document.errors[:version]).to be_nil
+    end
+  end
+
+  context "type validation" do
+    it "is valid if type is 'add'" do
+      document = described_class.new :type => "add"
+      document.valid?
+      expect(document.errors[:type]).to be_nil
+    end
+
+    it "is valid if type is 'delete'" do
+      document = described_class.new :type => "delete"
+      document.valid?
+      expect(document.errors[:type]).to be_nil
+    end
+
+    it "is invalid if type is anything else" do
+      document = described_class.new :type => "wrong"
+      document.valid?
+      expect(document.errors[:type]).to eq(["is invalid"])
+    end
+
+    it "is invalid if type is nil" do
+      document = described_class.new :type => nil
+      document.valid?
+      expect(document.errors[:type]).to eq(["can't be blank"])
+    end
+
+    it "is invalid if type is a blank string" do
+      document = described_class.new :type => "   "
+      document.valid?
+      expect(document.errors[:type]).to eq(["can't be blank"])
+    end
+  end
+
+  context "lang validation" do
+    context "when type is 'add'" do
+      it "is invalid if lang is nil" do
+        document = described_class.new :lang => nil, :type => "add"
+        document.valid?
+        expect(document.errors[:lang]).to eql(["can't be blank"])
+      end
+
+      it "is invalid if lang contains digits" do
+        document = described_class.new :lang => "a1", :type => "add"
+        document.valid?
+        expect(document.errors[:lang]).to eql(["is invalid"])
+      end
+
+      it "is invalid if lang contains more than 2 characters" do
+        document = described_class.new :lang => "abc", :type => "add"
+        document.valid?
+        expect(document.errors[:lang]).to eql(["is invalid"])
+      end
+
+      it "is invalid if lang contains upper case characters" do
+        document = described_class.new :lang => "Ab", :type => "add"
+        document.valid?
+        expect(document.errors[:lang]).to eql(["is invalid"])
+      end
+
+      it "is valid if lang contains 2 lower case characters" do
+        document = described_class.new :lang => "en", :type => "add"
+        document.valid?
+        expect(document.errors[:lang]).to be_nil
+      end
+    end
+
+    context "when type is 'delete'" do
+      it "is optional" do
+        document = described_class.new :type => "delete"
+        document.valid?
+        expect(document.errors[:lang]).to be_nil
+      end
+    end
+  end
+
+  context "fields validation" do
+    context "when type is 'add'" do
+      it "is invalid if fields is nil" do
+        document = described_class.new :fields => nil, :type => "add"
+        document.valid?
+        expect(document.errors[:fields]).to eql(["can't be empty"])
+      end
+
+      it "is invalid if fields is not a hash" do
+        document = described_class.new :fields => [], :type => "add"
+        document.valid?
+        expect(document.errors[:fields]).to eql(["must be an instance of Hash"])
+      end
+
+      it "is valid with a Hash" do
+        document = described_class.new :fields => {}, :type => "add"
+        document.valid?
+        expect(document.errors[:fields]).to be_nil
+      end
+    end
+
+    context "when type is 'delete'" do
+      it "is optional" do
+        document = described_class.new :type => "delete"
+        document.valid?
+        expect(document.errors[:fields]).to be_nil
+      end
+    end
+  end
+
+  context "#as_json" do
+    let(:attributes) { {
+      :type    => type,
+      :id      => "123abc",
+      :version => 123456,
+      :lang    => "pt",
+      :fields  => {:foo => "bar"}
+    } }
+    let(:document) { described_class.new attributes }
+    let(:as_json) { document.as_json }
+
+    context "when 'type' is 'add'" do
+      let(:type) { "add" }
+
+      it "includes the 'type' attribute" do
+        expect(as_json[:type]).to eq("add")
+      end
+
+      it "includes the 'id' attribute" do
+        expect(as_json[:id]).to eq("123abc")
+      end
+
+      it "includes the 'version' attribute" do
+        expect(as_json[:version]).to eq(123456)
+      end
+
+      it "includes the 'lang' attribute" do
+        expect(as_json[:lang]).to eq("pt")
+      end
+
+      it "includes the 'fields' attribute" do
+        expect(as_json[:fields]).to eq(:foo => "bar")
+      end
+    end
+
+    context "when 'type' is 'delete'" do
+      let(:type) { "delete" }
+
+      it "includes the 'type' attribute" do
+        expect(as_json[:type]).to eq("delete")
+      end
+
+      it "includes the 'id' attribute" do
+        expect(as_json[:id]).to eq("123abc")
+      end
+
+      it "includes the 'version' attribute" do
+        expect(as_json[:version]).to eq(123456)
+      end
+
+      it "does not include the 'lang' attribute" do
+        expect(as_json[:lang]).to be_nil
+      end
+
+      it "does not include the 'fields' attribute" do
+        expect(as_json[:fields]).to be_nil
+      end
+    end
+  end
+
+  context "#to_json" do
+    let(:attributes) { {
+      :type    => type,
+      :id      => "123abc",
+      :version => 123456,
+      :lang    => "pt",
+      :fields  => {:foo => "bar"}
+    } }
+    let(:parsed_json) { JSON.parse(described_class.new(attributes).to_json) }
+
+    context "when 'type' is 'add'" do
+      let(:type) { "add" }
+
+      it "includes the 'type' attribute" do
+        expect(parsed_json["type"]).to eq("add")
+      end
+
+      it "includes the 'id' attribute" do
+        expect(parsed_json["id"]).to eq("123abc")
+      end
+
+      it "includes the 'version' attribute" do
+        expect(parsed_json["version"]).to eq(123456)
+      end
+
+      it "includes the 'lang' attribute" do
+        expect(parsed_json["lang"]).to eq("pt")
+      end
+
+      it "includes the 'fields' attribute" do
+        expect(parsed_json["fields"]).to eq("foo" => "bar")
+      end
+    end
+
+    context "when 'type' is 'delete'" do
+      let(:type) { "delete" }
+
+      it "includes the 'type' attribute" do
+        expect(parsed_json["type"]).to eq("delete")
+      end
+
+      it "includes the 'id' attribute" do
+        expect(parsed_json["id"]).to eq("123abc")
+      end
+
+      it "includes the 'version' attribute" do
+        expect(parsed_json["version"]).to eq(123456)
+      end
+
+      it "does not include the 'lang' attribute" do
+        expect(parsed_json["lang"]).to be_nil
+      end
+
+      it "does not include the 'fields' attribute" do
+        expect(parsed_json["fields"]).to be_nil
+      end
+    end
+  end
+end
+

data/spec/cloud_search/indexer_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe CloudSearch::Indexer do
+  let(:indexer) { described_class.new }
+
+  describe "#documents" do
+    it "returns the list of documents to be indexed" do
+      doc1 = stub.as_null_object
+      doc2 = stub.as_null_object
+      indexer << doc1
+      indexer << doc2
+      expect(indexer.documents).to eq([doc1, doc2])
+    end
+
+    it "returns a frozen version of the documents list" do
+      expect {
+        indexer.documents << stub
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "#<<" do
+    let(:document) { stub :valid? => true }
+
+    it "adds a new item to the list of documents" do
+      indexer << document
+      expect(indexer.documents).to have(1).item
+    end
+
+    it "is aliased to #add" do
+      indexer.add document
+      expect(indexer.documents).to have(1).item
+    end
+
+    it "raises an exception if the document is invalid" do
+      expect {
+        indexer << stub(:valid? => false, :errors => {})
+      }.to raise_error(CloudSearch::InvalidDocument)
+    end
+  end
+
+  describe "#index" do
+    let(:document) { CloudSearch::Document.new(
+      :type    => type,
+      :id      => 678,
+      :version => version,
+      :lang    => :en,
+      :fields  => {:actor => ["Cassio Marques", "Willian Fernandes"], :director => ["Lucas, George"], :title => "Troy Wars"}
+    ) }
+    let(:indexer) { described_class.new }
+
+    context "adding a new document" do
+      around do |example|
+        VCR.use_cassette "index/request/add", &example
+      end
+
+      let(:type) { "add" }
+      let(:version) { 1 }
+      let(:url) { "#{CloudSearch.config.document_url}/documents/batch" }
+      let(:json) { [document].to_json }
+
+      it "succeeds" do
+        indexer << document
+        resp, message = indexer.index
+        expect(resp["status"]).to eq("success")
+        expect(resp["adds"]).to eq(1)
+        expect(resp["deletes"]).to eq(0)
+        expect(message).to match(/^200/)
+      end
+
+      it "sends http headers with json format info" do
+        indexer << document
+        RestClient.should_receive(:post).with(url, kind_of(String), {"Content-Type" => "application/json", "Accept" => "application/json" }).and_return(stub(:code => 1, :length => 10, :body => '{}'))
+        indexer.index
+      end
+
+      context "when the domain id was not configured" do
+        around do |example|
+          domain_id = CloudSearch.config.domain_id
+          CloudSearch.config.domain_id = nil
+          example.call
+          CloudSearch.config.domain_id = domain_id
+        end
+
+        it "raises an error" do
+          expect {
+            indexer.index
+          }.to raise_error(CloudSearch::MissingConfigurationError, "Missing 'domain_id' configuration parameter")
+        end
+      end
+
+      context "when the domain name was not configured" do
+        around do |example|
+          domain_name = CloudSearch.config.domain_name
+          CloudSearch.config.domain_name = nil
+          example.call
+          CloudSearch.config.domain_name = domain_name
+        end
+
+        it "raises an error" do
+          expect {
+            indexer.index
+          }.to raise_error(CloudSearch::MissingConfigurationError, "Missing 'domain_name' configuration parameter")
+        end
+      end
+    end
+
+    context "adding a batch of documents" do
+      around do |example|
+        VCR.use_cassette "index/request/add_in_batch", &example
+      end
+
+      let(:type) { "add" }
+      let(:version) { 5 }
+
+      it "succeeds" do
+        indexer << document
+        document2 = CloudSearch::Document.new :type => type, :version => version, :id => 679, :lang => :en, :fields => {:title => "Fight Club"}
+        document3 = CloudSearch::Document.new :type => type, :version => version, :id => 680, :lang => :en, :fields => {:title => "Lord of the Rings"}
+        indexer << document2
+        indexer << document3
+        resp, message = indexer.index
+        expect(resp["adds"]).to eq(3)
+        expect(resp["status"]).to eq("success")
+      end
+    end
+
+    context "deleting a document" do
+      around do |example|
+        VCR.use_cassette "index/request/delete", &example
+      end
+
+      let(:type) { "delete" }
+      let(:version) { 2 }
+
+      it "succeeds" do
+        indexer << document
+        resp, message = indexer.index
+        expect(resp["status"]).to eq("success")
+        expect(resp["adds"]).to eq(0)
+        expect(resp["deletes"]).to eq(1)
+        expect(message).to match(/^200/)
+      end
+    end
+  end
+end

data/spec/cloud_search/invalid_document_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe CloudSearch::InvalidDocument do
+  let(:document) { CloudSearch::Document.new }
+
+  it "has a message with the document errors" do
+    expect(described_class.new(document).message).to eq("id: can't be blank; version: can't be blank; type: can't be blank")
+  end
+end