stretch 0.1.0 → 0.1.1

data/lib/stretch/client.rb

@@ -1,83 +1,21 @@
 require "stretch/connection"
-require "stretch/uri_builder"
+require "stretch/cluster"
+require "stretch/index"
 
 module Stretch
   class Client
-    attr_reader :connection, :scope
-
     def initialize options = {}
       self.tap do
-        @scope = {
-          :cluster => false,
-          :index   => nil
-        }
-
         @connection = Stretch::Connection.new options
       end
     end
 
-    # Chainable methods
     def cluster
-      self.tap do
-        scope[:cluster] = true
-        scope[:index] = nil
-      end
+      Cluster.new @connection
     end
 
     def index name
-      self.tap do
-        scope[:cluster] = false
-        scope[:index]   = name
-      end
-    end
-
-    # End points
-    def health options = {}
-      with_scopes :cluster, :index do
-        connection.get build_path("/health"), options
-      end
-    end
-
-    def state options = {}
-      with_scopes :cluster do
-        connection.get build_path("/state"), options
-      end
-    end
-
-    def settings options = {}
-      with_scopes :cluster, :index do
-        if options.any?
-          connection.put build_path("/settings"), options
-        else
-          connection.get build_path("/settings")
-        end
-      end
-    end
-
-    def open!
-      with_scopes :index do
-        connection.post build_path("/_open")
-      end
-    end
-
-    def close!
-      with_scopes :index do
-        connection.post build_path("/_close")
-      end
-    end
-
-    private
-    def build_path path
-      Stretch::URIBuilder.build_from_scope scope, path
-    end
-
-    def with_scopes *scopes, &block
-      if scopes.any? {|s| scope.has_key?(s) && scope[s] }
-        yield
-      else
-        raise InvalidScope,
-          "Requires one of the following scopes: #{scopes.inspect}. #{scope.inspect} given."
-      end
+      Index.new name, @connection
     end
   end
 end

data/lib/stretch/cluster.rb

@@ -0,0 +1,43 @@
+module Stretch
+  class Cluster
+    attr_reader :connection
+
+    def initialize connection
+      @connection = connection
+    end
+
+    def health options = {}
+      indices = options.delete(:indices) if options.has_key? :indices
+
+      path = "/health"
+
+      if indices
+        path << "/#{[indices].flatten.join(',')}"
+        options[:level] = "indices"
+      end
+
+      get path, options
+    end
+
+    def state options = {}
+      get "/state", options
+    end
+
+    def settings options = {}
+      if options.any?
+        put "/settings", options
+      else
+        get "/settings"
+      end
+    end
+
+    private
+    def get path, options = {}
+      @connection.request :get, "/_cluster#{path}", options
+    end
+
+    def put path, options = {}
+      @connection.request :put, "/_cluster#{path}", options
+    end
+  end
+end

data/lib/stretch/connection.rb

@@ -11,23 +11,6 @@ module Stretch
       @connection = Faraday.new(options)
     end
 
-    def get path, options = {}
-      request :get, path, options
-    end
-
-    def post path, options = {}
-      request :post, path, options
-    end
-
-    def put path, options = {}
-      request :put, path, options
-    end
-
-    def delete path, options = {}
-      request :delete, path, options
-    end
-
-    private
     def request method, path, options = {}
       validate_request_method method
 
@@ -46,6 +29,7 @@ module Stretch
       handle_response response
     end
 
+    private
     def validate_request_method method
       unless REQUEST_METHODS.member? method
         raise Stretch::UnsupportedRequestMethod, "#{method} is not supported!"
@@ -55,7 +39,7 @@ module Stretch
     def handle_response response
       if response.success?
         if response.body.empty?
-          request :get, path
+          { "ok" => true }
         else
           MultiJson.load response.body
         end

data/lib/stretch/index.rb

@@ -0,0 +1,41 @@
+module Stretch
+  class Index
+    attr_reader :name, :connection
+
+    def initialize name, connection
+      raise ArgumentError if name.nil? || name.empty?
+
+      @name = name
+      @connection = connection
+    end
+
+    def settings options = {}
+      if options.any?
+        put "/_settings", options
+      else
+        get("/_settings")[@name]["settings"]
+      end
+    end
+
+    def open
+      post "/_open"
+    end
+
+    def close
+      post "/_close"
+    end
+
+    private
+    def get path, options = {}
+      @connection.request :get, "/#{@name}#{path}", options
+    end
+
+    def put path, options = {}
+      @connection.request :put, "/#{@name}#{path}", options
+    end
+
+    def post path, options = {}
+      @connection.request :post, "/#{@name}#{path}", options
+    end
+  end
+end

data/lib/stretch/version.rb

@@ -1,3 +1,3 @@
 module Stretch
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/test/stretch/client_test.rb

@@ -4,150 +4,12 @@ require "stretch/client"
 
 describe Stretch::Client do
   let(:instance) { described_class.new }
-  let(:connection) { MiniTest::Mock.new }
 
-  describe ".new" do
-    describe "scope defaults" do
-      it "index to nil" do
-        assert_nil instance.scope[:index]
-      end
-
-      it "cluster to false" do
-        refute instance.scope[:cluster]
-      end
-    end
-  end
-
-  it "can chain index" do
-    assert instance.index("foo").is_a?(Stretch::Client)
-    assert_equal "foo", instance.scope[:index]
-  end
-
-  it "can chain cluster" do
-    assert instance.cluster.is_a?(Stretch::Client)
-    assert instance.scope[:cluster]
-  end
-
-  describe "#health" do
-    it "requires either a cluster scope or an index scope" do
-      instance.stub :scope, { :cluster => false, :index => nil } do
-        assert_raises Stretch::InvalidScope do
-          instance.health
-        end
-      end
-    end
-
-    it "requests cluster health if the scope is cluster" do
-      instance.stub :connection, connection do
-        connection.expect :get, { "status" => "ok" }, ["/_cluster/health", {}]
-        instance.cluster.health
-
-        connection.verify
-      end
-    end
-
-    it "requests index health if the scope is an index" do
-      instance.stub :connection, connection do
-        connection.expect :get, { "status" => "ok" }, ["/foo/health", {}]
-        instance.index("foo").health
-
-        connection.verify
-      end
-    end
-  end
-
-  describe "#state" do
-    it "requires a cluster scope" do
-      instance.stub :scope, { :cluster => false } do
-        assert_raises Stretch::InvalidScope do
-          instance.state
-        end
-      end
-    end
-
-    it "can return the state of a cluster" do
-      instance.connection.stub :get, { "status" => "ok" } do
-        assert_equal "ok", instance.cluster.state["status"]
-      end
-    end
-  end
-
-  describe "#settings" do
-    it "requires either a cluster scope or an index scope" do
-      instance.stub :scope, { :cluster => false, :index => nil } do
-        assert_raises Stretch::InvalidScope do
-          instance.settings
-        end
-      end
-    end
-
-    describe "no options given" do
-      it "performs a get request for the settings" do
-        response = { "persistent" => { "foo" => 1 } }
-
-        instance.stub :connection, connection do
-          connection.expect :get, response, ["/_cluster/settings"]
-          assert_equal 1, instance.cluster.settings["persistent"]["foo"]
-
-          connection.verify
-        end
-      end
-    end
-
-    describe "options given" do
-      it "performs a put request with options for the settings" do
-        params   = { :index => { :refresh_interval => -1 } }
-        response = { "index" => {"refresh_interval" => -1} }
-
-        instance.stub :connection, connection do
-          connection.expect :put, response, ["/foo/settings", params]
-          assert_equal -1, instance.index("foo").settings(params)["index"]["refresh_interval"]
-
-          connection.verify
-        end
-      end
-    end
+  it "#index" do
+    assert instance.index("foo").is_a?(Stretch::Index)
   end
 
-  describe "#open!" do
-    it "requires the index scope" do
-      instance.stub :scope, { :cluster => true, :index => nil } do
-        assert_raises Stretch::InvalidScope do
-          instance.open!
-        end
-      end
-    end
-
-    it "performs a post request to open the index" do
-      response = { "ok" => true, "acknowledged" => true }
-
-      instance.stub :connection, connection do
-        connection.expect :post, response, ["/foo/_open"]
-        assert_equal true, instance.index("foo").open!["ok"]
-
-        connection.verify
-      end
-    end
-  end
-
-  describe "#close!" do
-    it "requires the index scope" do
-      instance.stub :scope, { :cluster => true, :index => nil } do
-        assert_raises Stretch::InvalidScope do
-          instance.close!
-        end
-      end
-    end
-
-    it "performs a post request to close the index" do
-      response = { "ok" => true, "acknowledged" => true }
-
-      instance.stub :connection, connection do
-        connection.expect :post, response, ["/foo/_close"]
-        assert_equal true, instance.index("foo").close!["ok"]
-
-        connection.verify
-      end
-    end
+  it "#cluster" do
+    assert instance.cluster.is_a?(Stretch::Cluster)
   end
 end

data/test/stretch/cluster_test.rb

@@ -0,0 +1,74 @@
+require "test_helper"
+
+require "stretch/cluster"
+
+describe Stretch::Cluster do
+  let(:connection) { MiniTest::Mock.new }
+  let(:instance)   { described_class.new connection }
+
+  describe "#initialize" do
+    it "assigns connection" do
+      connection.expect :==, true, [connection]
+
+      assert_equal connection, described_class.new(connection).connection
+    end
+  end
+
+  describe "#health" do
+    it "sends a get request for health with options" do
+      connection.expect :request,
+        { "status" => "ok" },
+        [:get, "/_cluster/health", { :timeout => "2s" }]
+
+      instance.health :timeout => "2s"
+
+      connection.verify
+    end
+
+    describe "with indices option" do
+      it "sends a get request for indices health with correct level" do
+        connection.expect :request,
+          { "indices" => { "foo" => {}, "bar" => {} } },
+          [:get, "/_cluster/health/foo,bar", { :level => "indices", :timeout => "2s" }]
+
+        instance.health :indices => ["foo", "bar"], :timeout => "2s"
+
+        connection.verify
+      end
+    end
+  end
+
+  describe "#state" do
+    it "sends a get request for the state of the cluster" do
+      connection.expect :request,
+        { "nodes" => [1,2,3], "metadata" => { "foo" => "bar" }},
+        [:get, "/_cluster/state", { :filter_routing_table => true }]
+
+      instance.state :filter_routing_table => true
+
+      connection.verify
+    end
+  end
+
+  describe "#settings" do
+    it "sends a put request if there are any options" do
+      connection.expect :request,
+        { "ok" => true },
+        [:put, "/_cluster/settings", { :foo => "bar" }]
+
+      instance.settings :foo => "bar"
+
+      connection.verify
+    end
+
+    it "sends a get request if there are no options" do
+      connection.expect :request,
+        { "foo" => "bar" },
+        [:get, "/_cluster/settings", {}]
+
+      instance.settings
+
+      connection.verify
+    end
+  end
+end

data/test/stretch/connection_test.rb

@@ -4,39 +4,4 @@ require "stretch/connection"
 
 describe Stretch::Connection do
   let(:instance) { described_class.new }
-  let(:response) do
-    Struct.new :response do
-      def body
-        MultiJson.dump({ "status" => "ok" })
-      end
-
-      def success?
-        true
-      end
-    end.new
-  end
-
-  it "accepts get requests" do
-    instance.connection.stub :get, response do
-      instance.get "/foo"
-    end
-  end
-
-  it "accepts post requests" do
-    instance.connection.stub :post, response do
-      instance.post "/foo"
-    end
-  end
-
-  it "accepts put requests" do
-    instance.connection.stub :put, response do
-      instance.put "/foo"
-    end
-  end
-
-  it "accepts delete requests" do
-    instance.connection.stub :delete, response do
-      instance.delete "/foo"
-    end
-  end
 end

data/test/stretch/index_test.rb

@@ -0,0 +1,77 @@
+require "test_helper"
+
+require "stretch/index"
+
+describe Stretch::Index do
+  let(:connection) { MiniTest::Mock.new }
+  let(:instance)   { described_class.new "foo", connection }
+
+  describe "#initialize" do
+    it "raises an ArgumentError if the index name is nil" do
+      assert_raises ArgumentError do
+        described_class.new nil, connection
+      end
+    end
+
+    it "raises an ArgumentError if the index name is empty" do
+      assert_raises ArgumentError do
+        described_class.new "", connection
+      end
+    end
+
+    it "sets the name and the connection" do
+      connection.expect :==, true, [connection]
+
+      assert_equal "foo", instance.name
+      assert_equal connection, instance.connection
+
+      connection.verify
+    end
+  end
+
+  describe "#settings" do
+    it "sends a put request if there are any options" do
+      connection.expect :request,
+        { "ok" => true },
+        [:put, "/foo/_settings", { :foo => "bar" }]
+
+      instance.settings :foo => "bar"
+
+      connection.verify
+    end
+
+    it "sends a get request if there are no options" do
+      connection.expect :request,
+        { "foo" => "bar" },
+        [:get, "/foo/_settings", {}]
+
+      instance.settings
+
+      connection.verify
+    end
+  end
+
+  describe "#open" do
+    it "sends a post request to open the index" do
+      connection.expect :request,
+        { "ok" => true },
+        [:post, "/foo/_close", {}]
+
+      instance.close
+
+      connection.verify
+    end
+  end
+
+  describe "#close" do
+    it "sends a post request to close the index" do
+      connection.expect :request,
+        { "ok" => true },
+        [:post, "/foo/_open", {}]
+
+      instance.open
+
+      connection.verify
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stretch
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-14 00:00:00.000000000 Z
+date: 2013-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -123,14 +123,18 @@ files:
 - Rakefile
 - lib/stretch.rb
 - lib/stretch/client.rb
+- lib/stretch/cluster.rb
 - lib/stretch/connection.rb
+- lib/stretch/index.rb
 - lib/stretch/uri_builder.rb
 - lib/stretch/version.rb
 - script/bootstrap
 - script/test
 - stretch.gemspec
 - test/stretch/client_test.rb
+- test/stretch/cluster_test.rb
 - test/stretch/connection_test.rb
+- test/stretch/index_test.rb
 - test/stretch_test.rb
 - test/test_helper.rb
 homepage: https://github.com/wfarr/stretch
@@ -146,18 +150,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3712832259908765
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3712832259908765
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -167,6 +165,8 @@ summary: It's not anywhere near complete at this time, but the code is pretty al
   right allegedly.
 test_files:
 - test/stretch/client_test.rb
+- test/stretch/cluster_test.rb
 - test/stretch/connection_test.rb
+- test/stretch/index_test.rb
 - test/stretch_test.rb
 - test/test_helper.rb