khoj 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+
+gem 'rake'
+# Specify your gem's dependencies in khoj.gemspec
+gemspec

data/README.md

@@ -0,0 +1,2 @@
+About Khoj
+===========

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => :test
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' <<'test'
+  test.pattern =  'test/*_test.rb'
+  test.verbose = true
+end

data/khoj.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/khoj/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jiren", "Siva", 'Swapnil', 'Pratik']
+  gem.email         = ["jiren@joshsoftware.com,siva@joshsoftware.com,
+    swapnil@joshsoftware.com,pratik@joshsoftware.com"]
+  gem.description   = %q{Elastic search client}
+  gem.summary       = %q{Elastic search client}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "khoj"
+  gem.require_paths = ["lib"]
+  gem.version       = Khoj::VERSION
+  gem.add_dependency('json', '>= 1.5.3')
+  gem.add_dependency("httparty", ">= 0.7.8")
+
+  gem.add_development_dependency('activesupport', '>= 3.0.0')
+  gem.add_development_dependency('i18n')
+end

data/lib/generators/khoj/khoj_generator.rb

@@ -0,0 +1,20 @@
+class KhojGenerator < Rails::Generators::Base
+
+	source_root File.expand_path('../templates', __FILE__)  
+	class_option :api_key, :aliases => '-k', :type => :string, :desc => 'API key.'
+
+	def add_config
+		if options[:api_key]
+			template 'initializer.rb', 'config/initializers/khoj.rb'
+		else
+		  p 'Set option --api-key or -k.'
+		end
+	end
+
+	private
+	def api_key
+		"'#{options[:api_key]}'"
+	end
+
+end
+

data/lib/generators/khoj/templates/initializer.rb

@@ -0,0 +1,5 @@
+Khoj.config do |c|
+  c.api_key = <%= api_key %>
+  c.api_host = 'http://test.search.com'
+end
+

data/lib/khoj.rb

@@ -0,0 +1,49 @@
+require 'json'
+require 'httparty'
+
+require 'khoj/version'
+require 'khoj/configuration'
+require 'khoj/index'
+require 'khoj/client'
+require 'khoj/function'
+
+module Khoj
+
+  class KhojException < Exception
+    def initialize(message)
+      message = message['error'] if message.class == Hash
+      super "[KHOJ] #{message}"
+    end
+  end
+
+  def self.config(&block)
+    yield Configuration
+
+    unless Configuration.api_host
+      Configuration.api_host = Configuration::DEFAULTS[:api_host]
+    end
+
+    if Configuration.api_key.nil? or Configuration.api_key.strip.empty?
+      Configuration.valid = false
+      raise KhojException.new('api key is nil.')
+    end
+
+    Configuration.valid = true
+    #Configuration.freeze
+  end
+
+  @@clients = {} 
+
+  def self.client(index)
+    @@clients[index] ||= Client.new(index)
+  end
+
+  @@functions = {}
+  
+  def self.function(index)
+    @@functions[index] ||= Function.new(index)
+  end
+
+
+
+end

data/lib/khoj/client.rb

@@ -0,0 +1,142 @@
+module Khoj
+  class Client
+    include Index
+
+    DEFAULT_DOC_TYPE  = 'default'
+    DEFAULT_DOC_FIELD = 'text'
+    DEFAULT_SEARCH_LIMIT = 10
+    DEFAULT_ORDER = 'asc'
+
+    attr_accessor :index
+    attr_reader   :_index
+
+    #alias_method :update_categories, :add
+
+
+    def initialize(index)
+      @index = index
+      @_index = "#{Configuration.api_key}-#{index}"
+      @conn = Configuration.connection
+    end
+
+    def get(resource_id, options = {})
+      response = @conn.get("/#{_index}/#{resource_type(resource_id).join('/')}")
+      response.parsed_response
+    end
+
+    def add(resource_id, options = {})
+      resource_name, id = resource_type(resource_id)
+      resource = if options.class == String
+                   return if options.strip.empty?
+                   { DEFAULT_DOC_FIELD => options}
+                 else
+                   return if options.empty?
+                   options
+                 end
+
+      req_options = {:body => resource.to_json, :format => 'json'}
+      response = @conn.post("/#{_index}/#{resource_name}/#{id}", req_options)
+
+      case response.code
+      when 200
+        true
+      when 201
+        true
+      else
+        raise KhojException.new(response.parsed_response)
+      end
+    end
+
+    def delete(resource_id)
+      id, resource_name =  resource_id.to_s.split(':').reverse
+      resource_type =  resource_name == nil ? [id] : [resource_name || DEFAULT_DOC_TYPE, id]
+      response = @conn.delete("/#{_index}/#{resource_type(resource_id).join('/')}")
+      response.code == 200
+    end
+
+    def search(query, options = {})
+      search_uri = options[:type] ? "#{options[:type]}/_search?pretty=true" : '_search?pretty=true'
+      
+      # check that if search string contains AND, OR or NOT in query
+      # if it is then we will execute String query of Query DSL
+      # else we will execute normal search query
+      if query.scan(/\sAND|NOT|OR+\s/).empty?
+        
+        options[:field] ||= DEFAULT_DOC_FIELD
+        q = {:query => 
+          {:term => { options[:field] => query}}
+        }
+        
+        #q[:query][:fields] ||= ['_id' , '_type']
+        q[:size] ||= (options[:size] ? (options[:size] > 10 ? DEFAULT_SEARCH_LIMIT : options[:size]) : DEFAULT_SEARCH_LIMIT) if options[:size]
+        q[:query] = q[:query].merge(:script_fields => { "#{options[:fetch]}" => { :script => "_source.#{options[:fetch]}"}}) if options[:fetch]
+      else
+        
+        # TODO : implement functionality for fetch action if specified by user to fetch fields from result set
+        q = get_string_query(query, options)
+      end
+      
+      if category_filter = options[:category_filter]
+        q[:facets] = {}
+        q[:filter] = {:term => {}}
+        category_filter.keys.each do |key|
+          q[:facets][key.to_s] = {:terms => {:field => key.to_s}, :facet_filter => {:term => {key => category_filter[key]}}}
+          q[:filter][:term].merge!({key => category_filter[key]}) 
+        end
+      end
+
+      #Check if sorting function is specified in the query.
+      #index.search 'test', :function => {:cordinates => "00,00", :order => 'desc'}
+      # "sort" => {:geo_location => {:cordinates => ["xx,yy"]}, :fields => {:price => 'xxx', :tags => 'xxx'}} 
+      if sort = options[:sort]
+        q["sort"] = []
+        sort.keys.each do |key|
+          if  key == :geo_location
+            q["sort"] << { "_geo_distance" =>  { "location" => "#{sort[:geo_location][:cordinates]}", "order" => "#{sort[:geo_location][:order] || DEFAULT_ORDER}", "unit" => "km" }}
+          else
+            q["sort"] << sort[:fields]
+          end
+        end
+      end
+      
+      response = @conn.get("/#{_index}/#{search_uri}", :body => q.to_json)
+
+      case response.code
+      when 200
+        response.parsed_response
+      else
+        nil
+      end
+    end
+
+    private
+    def resource_type(resource_id)
+      id, resource_name =  resource_id.to_s.split(':').reverse
+      return [resource_name || DEFAULT_DOC_TYPE, id]
+    end
+
+    def get_string_query(query, options)
+      q = {:query => 
+        {:query_string => { 
+          :query => query
+        }
+        }
+      }
+
+      # while using string query default field in elastic search is _all 
+      # if user specify fields then
+      #  if fields contains only one 1 field/word then pass it as 'default_field' parameter
+      #  if fields has more than 1 fields/words then pass them as 'fields' parameter
+      fields = options[:fields].split(',').each do |i| i.strip! end  if options[:fields]
+      if fields
+        if fields.size == 1
+          q[:query][:query_string] = q[:query][:query_string].merge(:default_field => fields[0]) 
+        elsif fields.size > 1
+          q[:query][:query_string] = q[:query][:query_string].merge(:fields => fields) 
+        end
+      end
+      return q
+    end
+
+  end
+end

data/lib/khoj/configuration.rb

@@ -0,0 +1,32 @@
+module Khoj
+  class Configuration
+    DEFAULTS = {
+      :api_host => 'http://localhost:9200'
+    }
+
+    class << self
+      attr_accessor :api_key
+      attr_accessor :api_host
+      attr_accessor :valid
+
+      def connection
+        @connection ||= Connection.new(:url => Configuration.api_host).class
+      end
+
+      def valid?
+        self.valid
+      end
+
+    end
+
+    class Connection
+      include HTTParty
+      format :json
+
+      def initialize(options = {})
+        self.class.base_uri(options[:url])
+      end
+    end
+
+  end
+end

data/lib/khoj/function.rb

@@ -0,0 +1,35 @@
+module Khoj
+  class Function
+    include Index
+
+    attr_accessor :index
+    attr_reader   :_index
+
+    def initialize(index)
+      @index = index
+      @_index = "#{Configuration.api_key}-#{index}"
+      @conn = Configuration.connection
+    end
+
+    def add(funtion_name, options ={})
+      type = options[:type]
+      if funtion_name == 'geo_location' 
+        geo_mapping =  { "#{type}" => { "properties" => { "location" => { "type" => "geo_point" } } } }
+        req_options = {:body => geo_mapping.to_json, :format => 'json'}
+        response = @conn.post("/#{_index}/#{type}/_mapping", req_options)
+        case response.code
+        when 200
+          true
+        when 201
+          true
+        else
+          raise KhojException.new(response.parsed_response)
+        end
+      else
+          raise KhojException.new('No function found with given name')
+      end
+    end
+
+  end
+end
+

data/lib/khoj/index.rb

@@ -0,0 +1,28 @@
+module Khoj
+  module Index
+
+    def create_index
+      response = @conn.put("/#{_index}")
+      response.code == 200 ? true : (raise KhojException.new(response.parsed_response))
+    end
+
+    def delete_index
+      response = @conn.delete("/#{_index}")
+      response.code == 200 ? true : (raise KhojException.new(response.parsed_response))
+    end
+
+    def index?
+      @conn.head("/#{_index}").code == 200 ? true : false 
+    end
+
+    def index_stats
+      response = @conn.get("/#{_index }/_stats")
+      if response.code == 200
+        response.parsed_response['_all']['total']['docs']['count']
+      else
+        raise KhojException.new(response.parsed_response) 
+      end
+    end
+
+  end
+end

data/lib/khoj/version.rb

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

data/test/client_test.rb

@@ -0,0 +1,246 @@
+require 'test_helper'
+
+class ClientTest < ActiveSupport::TestCase
+  def setup
+    @api_key = 'test-api-key'
+    @index = 'test-client'
+
+    Khoj.config do |c|
+      c.api_key = @api_key
+      c.api_host = Khoj::Configuration::DEFAULTS[:api_host]
+    end
+
+    @client = Khoj.client(@index)
+    @document = {:test => 'from the the test case'}
+  end
+
+  def teardown
+    @client.delete('1') rescue ''
+    @client.delete("test") rescue ''
+  end
+
+  test 'should be able to add document' do
+    response = @client.add('test:1', @document)
+    sleep(1)
+    assert_equal true, response
+  end
+
+  test 'should be able to add document to default document type' do
+    response = @client.add('1', @document) # like doc id 'default:1'
+    sleep(1)
+    assert_equal true, response
+  end
+
+  test 'should be able to add document with default text field if string is input' do
+    response = @client.add('1', 'test for default text field')
+    sleep(1)
+    assert_equal true, response
+  end
+
+  test 'should be able to retrive docuemt' do
+    @client.add('test:1', @document)
+    sleep(1)
+    response = @client.get('test:1')
+
+    assert_equal true, response['exists']
+  end
+
+  # default:1 : type => default, id => 1 
+  test 'should be able to retrive default type document' do
+    @client.add('1', @document)
+    sleep(1)
+    response = @client.get('1')
+
+    assert_equal true, response['exists']
+    assert_equal Khoj::Client::DEFAULT_DOC_TYPE, response['_type']
+  end
+
+  test 'should be able to delete document' do
+    @client.add('test:1', @document)
+    sleep(1)
+    response = @client.delete('test:1')
+    assert_equal true, response
+  end
+
+  test 'should be able to delete default type document' do
+    @client.add('1', @document)
+    sleep(1)
+    response = @client.delete('1')
+    assert_equal true, response
+  end
+
+  #Default doc type : 'default', Default filed : text
+  test 'should be able to search document using default type and field' do
+    @client.delete(100)
+    @client.add(100, 'xxx yyy zzz')
+    sleep(2)
+
+    response = @client.search('xxx')
+    
+    assert_equal 1, response['hits']['total'] 
+  end
+
+  test 'should be able to search document using field name' do
+    @client.add('test:2', {:test => 'test2'})
+    sleep(1)
+
+    response = @client.search('test2', {:field => 'test'})
+    assert_equal 1, response['hits']['total'] 
+  end
+
+  test 'should be able to search document by type' do
+    @client.add('test:3', {:test => 'test3'})
+    sleep(1)
+
+    response = @client.search('test3', {:field => 'test', :type => 'test'})
+    assert_equal 1, response['hits']['total'] 
+  end
+
+  #size
+  test 'should be able to search number of records as size is specified, 10 by default' do
+    15.times do |i|
+      @client.add("test:#{i+1}",  'test application')
+    end
+    sleep(1)
+    response = @client.search('test', :size => 0)
+    assert_equal 0, response['hits']['hits'].count
+
+    response = @client.search('test', :size => 5)
+    assert_equal 5, response['hits']['hits'].count 
+
+    response = @client.search('test')
+    assert_equal 10, response['hits']['hits'].count 
+
+    response = @client.search('test', :size => 15)
+    assert_equal 10, response['hits']['hits'].count 
+
+    6.times do |i|
+      @client.delete("test:#{i+1}") rescue ''
+    end
+    sleep(1)
+
+    response = @client.search('test')
+    assert_equal 9, response['hits']['hits'].count
+
+    response = @client.search('test', :size => 10)
+    assert_equal 9, response['hits']['hits'].count 
+
+    15.times do |i|
+      @client.delete("test:#{i+1}") rescue ''
+    end
+  end
+  
+  test 'should fetch specified field from documents from which search match is found, if not present then should return nil' do
+    field = 'designation'
+    designation = 'Software Engineer'
+  
+    # matching text 'software' with designation
+    @client.add('test:1', :text => 'I am a software engineer', :city => 'Pune', :designation => designation)
+  
+    # matching text without designation
+    @client.add('test:2', :text => 'I am a freelancer who developes software', :city => 'Mumbai')
+  
+    #unmatching text with designation
+    @client.add('test:3', :text => 'I do marketing of products', :city => 'Delhi', :designation => 'Marketing Executive')
+    sleep(1)
+  
+    response = @client.search('software', :fetch=> field)
+
+    ids = [] # ids array will contain ids of documents 
+    fields = []  # fields array will contain fetched fields, each field is in key => value format such as "fields"=>{"designation"=>"Software Engineer"}
+    field_values = [] # fields_values will contain values of fetched fields such as 'Software Engineer','Marketing Executive',nil etc.
+
+    # Data received in json format is,
+    # {
+    #   "took"=>5, "timed_out"=>false, "_shards"=>{"total"=>5, "successful"=>5, "failed"=>0}, 
+    #   "hits"=>{"total"=>2, "max_score"=>0.15342641, 
+    #            "hits"=>[
+    #                     {"_index"=>"test-api-key-test", "_type"=>"test", "_id"=>"1", "_score"=>0.15342641, "fields"=>{"designation"=>"Software Engineer"}}, 
+    #                     {"_index"=>"test-api-key-test", "_type"=>"test", "_id"=>"2", "_score"=>0.11506981, "fields"=>{"designation"=>nil}}
+    #                    ]
+    #           }
+    # }
+
+    response['hits']['hits'].each do |i|
+      ids << i['_id']
+      fields << i['fields']
+      field_values << i['fields'].values
+    end
+    field_values.flatten!
+    # as per data entered, hits should be 2 as word 'software' is in only 2 documents
+    assert_equal 2, response['hits']['total']
+
+    # fields array should contain uniq element as only one field is fetched  
+    assert_equal 1, fields.collect(&:keys).flatten.uniq.count
+
+    # key of every element in fields array should be 'designation'
+    assert_equal field, fields.collect(&:keys).flatten.uniq.first
+
+    # ids array should contain 1 and 2, not 3
+    assert_equal true, ids.include?('1')
+    assert_equal true, ids.include?('2')
+    assert_equal false, ids.include?('3')
+
+    # Designation value should be 
+    # software enginner for document test:1 and nil for test:2
+    # it should not contain value as Marketing Executive
+    assert_equal true, field_values.include?(designation)
+    assert_equal true, field_values.include?(nil)
+    assert_equal false, field_values.include?('Marketing Executive')
+
+  end
+
+  test 'should perofrm search operation using operators[AND/OR/NOT], when no field specified, default is all fields' do
+    add_data_with_multiple_fields
+
+    # Search data with operators using no fields specified 
+    response = @client.search('marketing OR tester')
+    ids = get_ids_from_response(response)
+    assert_equal 2, ids.size
+    assert_equal true, ids.include?('3')
+    assert_equal true, ids.include?('4')
+  end
+
+  test 'should perofrm operations using operators, when single field is specified' do
+    add_data_with_multiple_fields
+    # Search data with operators and within single field
+    response = @client.search('delhi OR mumbai', :fields => "city")
+    ids = get_ids_from_response(response)
+    assert_equal 2, response['hits']['total']
+    assert_equal true, ids.include?('2')
+    assert_equal true, ids.include?('3')
+    
+    response = @client.search('tester OR pune', :fields => "text")
+    assert_equal 0, response['hits']['total']
+  end
+
+  test 'should perofrm operations using operators, when multiple fields are specified' do
+    add_data_with_multiple_fields
+    # Search data with operators and with multiple fields
+    response = @client.search('software AND mumbai', :fields => "designation, city")
+    assert_equal 1, response['hits']['total']
+    assert_equal '2', response['hits']['hits'].first['_id']
+
+    response = @client.search('software OR pune NOT tester NOT manager NOT mumbai', :fields => "designation, city")
+    assert_equal 1, response['hits']['total']
+    assert_equal '1', response['hits']['hits'].first['_id']
+  end
+
+  def add_data_with_multiple_fields
+    # While changig data in this method make sure to do changed in all respective places as the data fields are used for validation of test cases
+    @client.add('test:1', :text => 'I am a software engineer', :city => 'Pune', :designation => 'Software engineer')
+    @client.add('test:2', :text => 'I am a freelancer who developes software', :city => 'Mumbai', :designation => 'Senior Software Engineer')
+    @client.add('test:3', :text => 'I do marketing of products', :city => 'Delhi', :designation => 'Marketing Executive')
+    @client.add('test:4', :text => 'I test the product', :city => 'Pune, University Road', :designation => 'Tester')
+    @client.add('test:5', :text => 'I manage the company', :city => 'Pune, Shivajinagar', :designation => 'Manager')
+    sleep(1)
+  end
+
+  def get_ids_from_response(response)
+    ids = []
+    response['hits']['hits'].each do |i|
+      ids << i['_id']
+    end
+    return ids
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class ConfigurationTest < ActiveSupport::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+end

data/test/facet_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class FacetTest < ActiveSupport::TestCase
+  def setup
+    @api_key = 'test-api-key'
+    @index = 'test-facet'
+
+    Khoj.config do |c|
+      c.api_key = @api_key
+      c.api_host = Khoj::Configuration::DEFAULTS[:api_host]
+    end
+
+    @client = Khoj.client(@index)
+    @document = {:test => 'from the the test case'}
+  end
+
+  def teardown
+    @client.delete('test:1') rescue ''
+    @client.delete('test:2') rescue ''
+    @client.delete('test:3') rescue ''
+  end
+
+  test 'should be able to filter facet count' do
+    @client.add('test:1', {:test => 'test1', :tags => ['foo']})
+    @client.add('test:2', {:test => 'test2', :tags => ['baz']})
+    sleep(5)   
+    response = @client.search('test1', {:field => 'test', :type => 'test', :category_filter =>{'tags' => ['foo']}})
+    assert_equal 1, response['facets']['tags']['total'] 
+    assert_equal 1, response['hits']['total'] 
+  end
+  
+  test 'facet count depends on search result' do
+    @client.add('test:1', {:test => 'test1', :tags => ['foo']})
+    @client.add('test:2', {:test => 'test2', :tags => ['foo']})
+    sleep(5)   
+  
+    response = @client.search('test1', {:field => 'test', :type => 'test', :category_filter =>{'tags' => ['foo']}})
+    
+    assert_equal 1, response['facets']['tags']['total'] 
+    assert_equal 1, response['hits']['total'] 
+  end
+
+  test 'should be able to filter multiple facet count' do
+    @client.add('test:3', {:test => 'test3', :tags => ['foo'], :location => 'london'})
+    sleep(5)   
+    
+    response = @client.search('test3', {:field => 'test', :type => 'test', :category_filter =>{'tags' => ['foo'], 'location' => 'london'}})
+    
+    assert_equal 1, response['facets']['tags']['total'] 
+    assert_equal 1, response['facets']['location']['total'] 
+    assert_equal 1, response['hits']['total'] 
+  end
+
+  test 'should perform AND operation on multiple value passed for single field' do
+    @client.add('test:1', {:test => 'test1', :tags => ['foo'], :location => ['pune', 'mumbai', 'delhi']})
+    @client.add('test:2', {:test => 'test2', :tags => ['foo'], :location => ['pune', 'mumbai']})
+    sleep(5)   
+  
+    response = @client.search('test1', {:field => 'test', :type => 'test', :category_filter =>{'location' => ['pune', 'mumbai', 'delhi']}})
+    assert_equal 3, response['facets']['location']['total'] 
+    assert_equal 1, response['hits']['total'] 
+  end
+
+end

data/test/function_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class FunctionTest < ActiveSupport::TestCase
+  
+  def setup
+    @api_key = 'test-api-key'
+    @index = 'test'
+
+    Khoj.config do |c|
+      c.api_key = @api_key
+      c.api_host = Khoj::Configuration::DEFAULTS[:api_host]
+    end
+
+    @client= Khoj.client(@index)
+    @function = Khoj.function(@index)
+  end
+
+  test 'should be able to map document field type to geo_type' do
+    response = @function.add('geo_location', :type => 'function_test')
+    sleep(1)
+    assert_equal true, response
+  end
+
+end

data/test/index_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class IndexTest < ActiveSupport::TestCase
+  def setup
+    @api_key = 'test-api-key'
+    @index   = 'test'
+
+    Khoj.config do |c|
+      c.api_key = @api_key
+      c.api_host = Khoj::Configuration::DEFAULTS[:api_host]
+    end
+  end
+
+  def teardown    
+    begin 
+       client = Khoj.client(@index)
+       client.delete_index
+    rescue Exception => e
+      ""
+    end
+  end
+
+  test 'should create index. check index exist or not and delete index' do
+    @index = "test_1"
+    client = Khoj.client(@index)
+
+    assert_equal true, client.create_index
+    assert_equal true, client.index?
+    assert_equal true, client.delete_index
+  end
+
+  test 'should throw exception on create if index already exist' do
+    @index = "test_2"
+    client = Khoj.client(@index)
+    client.create_index 
+
+    assert_raise Khoj::KhojException do
+      client.create_index
+    end
+  end
+
+  test 'should throw exception on delete if index not exist' do
+    @index = "test_3"
+    client = Khoj.client(@index)
+
+    assert_raise Khoj::KhojException do
+      client.delete_index
+    end
+  end
+
+  test 'should return index state' do
+    @index = "test_4"
+    client = Khoj.client(@index)
+    client.create_index
+
+    assert_equal 0, client.index_stats
+  end
+
+  test 'index name should be in lower case' do
+    @index = "TEST-INDEX"
+    client = Khoj.client(@index)
+
+    assert_raise Khoj::KhojException do
+      client.create_index
+    end
+  end
+
+end

data/test/khoj_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+
+class KhojTest < ActiveSupport::TestCase
+  def setup
+    @api_key = 'API-KEY'
+    @api_host = 'http://testclient.com'
+  end
+
+  def teardown
+  end
+
+  test 'should init configuration' do
+    Khoj.config do |c|
+      c.api_key = @api_key
+    end
+
+    assert_equal @api_key, Khoj::Configuration.api_key
+    assert_equal Khoj::Configuration::DEFAULTS[:api_host], Khoj::Configuration.api_host
+    assert_equal true, Khoj::Configuration.valid?
+  end
+
+  test 'for nil or empty api key config should not be valid' do
+    assert_raise Khoj::KhojException do
+      Khoj.config do |c|
+        c.api_key = nil
+      end
+    end
+
+    assert_raise Khoj::KhojException do
+      Khoj.config do |c|
+        c.api_key = "  "
+      end
+    end
+  end
+
+  test 'should set api host' do
+    Khoj.config do |c|
+      c.api_key = @api_key
+      c.api_host = @api_host 
+    end
+
+    assert_equal @api_host, Khoj::Configuration.api_host
+
+    Khoj::Configuration.api_host = Khoj::Configuration::DEFAULTS[:api_host]
+  end
+
+
+  test 'should create api client' do
+    api_key = 'test-api-key'
+    index = 'test'
+    Khoj.config do |c|
+      c.api_key = api_key
+      c.api_host = Khoj::Configuration::DEFAULTS[:api_host]
+    end
+
+    client = Khoj.client(index)
+
+    assert_equal 'test', client.index
+    assert_equal "#{api_key}-#{index}", client._index
+  end
+
+
+end

data/test/sort_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class SortTest < ActiveSupport::TestCase
+  
+  def setup
+    @api_key = 'test-api-key-new'
+    @index = 'test-new'
+
+    Khoj.config do |c|
+      c.api_key = @api_key
+      c.api_host = Khoj::Configuration::DEFAULTS[:api_host]
+    end
+
+    @client= Khoj.client(@index)
+    @function = Khoj.function(@index)
+    @function.add('geo_location', :type => 'sort_test')
+    @client.add('sort_test:1', :text => 'sort_test', :location => {:lat => '100.00', :lon => "100.00"}, :price => '100' ,:range => '200')
+    @client.add('sort_test:2', :text => 'sort_test', :location => {:lat => '50.00', :lon => "50.00"}, :price => '200', :range => '100')
+    @client.add('sort_test:3', :text => 'sort_test', :location => {:lat => '00.00', :lon => "00.00"}, :price => '300', :range => '100')
+    sleep(5)
+  end
+  
+  def teardown
+    
+  end
+
+  test 'should be able to sort document according to location in ascending order' do
+    response = @client.search 'sort_test', :sort => {:geo_location => {:cordinates => "100,100", :order => 'asc'}}, :size => 3, :type => 'sort_test'
+    assert_equal "1", response["hits"]["hits"][0]["_id"]
+    assert_equal "3", response["hits"]["hits"][1]["_id"]
+    assert_equal "2", response["hits"]["hits"][2]["_id"]
+  end
+
+  test 'should be able to sort document according to location in descending order' do
+    response = @client.search 'sort_test', :sort => {:geo_location => {:cordinates => "100,100", :order => 'desc'}}, :size => 3, :type => 'sort_test'
+    assert_equal "2", response["hits"]["hits"][0]["_id"]
+    assert_equal "3", response["hits"]["hits"][1]["_id"]
+    assert_equal "1", response["hits"]["hits"][2]["_id"]
+  end
+
+  test 'should be able to sort document according price range' do
+    response = @client.search 'sort_test', :sort => {:fields => {:price => "asc"}}, :size => 3, :type => 'sort_test'
+    assert_equal "1", response["hits"]["hits"][0]["_id"]
+    assert_equal "2", response["hits"]["hits"][1]["_id"]
+    assert_equal "3", response["hits"]["hits"][2]["_id"]
+  end
+  
+  test 'should be able to sort document primarily by range and then price range' do
+    response = @client.search 'sort_test', :sort => {:fields => {:range => 'desc', :price => "desc"}}, :size => 3, :type => 'sort_test'
+    assert_equal "1", response["hits"]["hits"][0]["_id"]
+    assert_equal "3", response["hits"]["hits"][1]["_id"]
+    assert_equal "2", response["hits"]["hits"][2]["_id"]
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require 'active_support/test_case'
+
+unless $LOAD_PATH.include? 'lib'
+  $LOAD_PATH.unshift(File.dirname(__FILE__))
+  $LOAD_PATH.unshift(File.join($LOAD_PATH.first, '..', 'lib'))
+end
+
+#NOTE: rake test TEST=test.rb 
+
+require 'khoj' 

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: khoj
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jiren
+- Siva
+- Swapnil
+- Pratik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &2162535300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *2162535300
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: &2162534800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.8
+  type: :runtime
+  prerelease: false
+  version_requirements: *2162534800
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2162534340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2162534340
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &2162533960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2162533960
+description: Elastic search client
+email:
+- ! "jiren@joshsoftware.com,siva@joshsoftware.com,\n    swapnil@joshsoftware.com,pratik@joshsoftware.com"
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- khoj.gemspec
+- lib/generators/khoj/khoj_generator.rb
+- lib/generators/khoj/templates/initializer.rb
+- lib/khoj.rb
+- lib/khoj/client.rb
+- lib/khoj/configuration.rb
+- lib/khoj/function.rb
+- lib/khoj/index.rb
+- lib/khoj/version.rb
+- test/client_test.rb
+- test/configuration_test.rb
+- test/facet_test.rb
+- test/function_test.rb
+- test/index_test.rb
+- test/khoj_test.rb
+- test/sort_test.rb
+- test/test_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.10
+signing_key: 
+specification_version: 3
+summary: Elastic search client
+test_files:
+- test/client_test.rb
+- test/configuration_test.rb
+- test/facet_test.rb
+- test/function_test.rb
+- test/index_test.rb
+- test/khoj_test.rb
+- test/sort_test.rb
+- test/test_helper.rb