elasticshell 0.0.2 → 0.0.4

data/spec/elasticshell/client_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Client do
+
+  before do
+    @client = Client.new
+  end
+
+  describe "before connecting" do
+
+    it "should not be connected on initialization" do
+      expect(@client.connected?).to be_false
+    end
+    
+    it "should raise an error when attempting to make a request before connecting" do
+      expect { @client.request("GET") }.to raise_error(ClientError)
+    end
+  end
+
+  describe "when connected" do
+
+    before do
+      @client.stub!(:connected?).and_return(true)
+      @client.stub!(:log_request)
+      @client.stub!(:perform_request)
+      @verb   = "GET"
+      @params = {:op => "/foobar"}
+    end
+
+    it "should log all requests by default" do
+      @client.should_receive(:log_request).with(@verb, @params, {})
+      @client.request(@verb, @params)
+    end
+
+    it "should allow skipping request logging when asked" do
+      @client.should_not_receive(:log_request)
+      @client.request(@verb, @params, {:log => false})
+    end
+    
+    it "wrap client library errors in its own custom error class" do
+      @client.stub!(:perform_request).and_raise(ElasticSearch::RequestError)
+      expect { @client.request(@verb, @params) }.to raise_error(ClientError)
+    end
+
+    it "should return safely from a client library error if asked" do
+      @client.stub!(:perform_request).and_raise(ElasticSearch::RequestError)
+      expect(@client.request(@verb, @params, {:safely => true, :return => 3})).to eq(3)
+      expect(@client.safely(@verb, @params)).to be_nil
+    end
+
+    
+    
+  end
+
+end

data/spec/elasticshell/commands/blank_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Commands::Blank do
+
+  before do
+    @shell = Shell.new
+  end
+
+  it "should do nothing" do
+    @shell.eval_line("")
+    expect(@shell.line).to eq(1)
+  end
+  
+end

data/spec/elasticshell/commands/cd_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Commands::Cd do
+
+  before do
+    @shell  = Shell.new(:output => FakeOutput.new, :error => FakeOutput.new)
+  end
+  
+  it "should change scope when given an argument" do
+    expect(@shell.eval_line("cd /foo").path).to eq("/foo")
+  end
+
+  it "should change to the global scope when given no argument" do
+    expect(@shell.eval_line("cd /foo").eval_line("cd").path).to eq("/")
+  end
+
+  it "should properly interpret relative path names" do
+    expect(@shell.eval_line("cd /foo").eval_line("cd ..").path).to eq("/")
+    expect(@shell.eval_line("cd /foo/bar").eval_line("cd ..").path).to eq("/foo")
+    expect(@shell.eval_line("cd /foo/bar").eval_line("cd ../baz").path).to eq("/foo/baz")
+  end
+  
+end

data/spec/elasticshell/commands/connect_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Commands::Connect do
+
+  
+  before do
+    @shell = Shell.new
+  end
+
+  it "should start a connection to the default servers" do
+    @shell.client.should_receive(:connect).with()
+    expect(@shell.eval_line("connect"))
+  end
+
+  it "should start a connection to the given comma-separated servers" do
+    @shell.client.should_receive(:connect).with(:servers => %w[http://123.123.123.123:9200 http://321.321.321.321:9200])
+    expect(@shell.eval_line("connect http://123.123.123.123:9200 http://321.321.321.321:9200"))
+  end
+  
+  
+end

data/spec/elasticshell/commands/df_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Commands::Df do
+
+  before do
+    @shell  = Shell.new(:output => FakeOutput.new)
+  end
+
+  it "should produce a summary of disk usage by index" do
+    @global = mock("Global scope")
+    @shell.stub!(:connected?).and_return(true)
+    @shell.stub!(:scope_from_path).with("/").and_return(@global)
+    @global.stub!(:status).and_return({"indices"=>{"foo"=>{"index"=>{"size"=>"986b", "size_in_bytes"=>"986"}}}})
+    @shell.eval_line("df")
+    expect(@shell.output.read).to match(/986.+986b.+foo/)
+  end
+  
+end

data/spec/elasticshell/commands/help_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Commands::Help do
+
+  before do
+    @shell  = Shell.new(:output => FakeOutput.new)
+  end
+
+  it "should output some help text" do
+    @shell.eval_line("help")
+    expect(@shell.line).to eq(1)
+  end
+
+  it "should output some extra help text when asked" do
+    @shell.eval_line("help")
+    help = @shell.output.read.size
+    @shell.eval_line("help help")
+    expect(@shell.output.read.size).to be > help
+  end
+  
+end

data/spec/elasticshell/commands/ls_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Commands::Ls do
+
+  before do
+    @shell = Shell.new(:output => FakeOutput.new)
+    @shell.stub!(:connected?).and_return(true)
+  end
+
+  it "should provide a listing of the current scope's contents" do
+    @shell.scope.should_receive(:refresh!)
+    @shell.scope.stub!(:scopes).and_return(["snap", "crackle"])
+    @shell.eval_line("ls")
+    expect(@shell.output.read).to match(/crackle.+snap/)
+  end
+
+  it "should provide a long listing of the current scope's contents" do
+    @shell.scope.should_receive(:refresh!)
+    @shell.scope.stub!(:scopes).and_return(["snap", "crackle"])
+    @shell.eval_line("ll")
+    expect(@shell.output.read).to match(/^s.+crackle.*$\ns.+snap.*$/)
+  end
+  
+end

data/spec/elasticshell/commands/pretty_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Commands::Pretty do
+
+  before do
+    @shell = Shell.new
+  end
+
+  it "should set the shell to pretty when it's not pretty" do
+    @shell.eval_line("pretty")
+    expect(@shell.pretty?).to be_true
+  end
+
+  it "should set the shell to pretty when it's not pretty" do
+    @shell.eval_line("pretty").eval_line("pretty")
+    expect(@shell.pretty?).to be_false
+  end
+  
+end

data/spec/elasticshell/commands/pwd_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Commands::Pwd do
+
+  before do
+    @shell = Shell.new(:output => FakeOutput.new)
+  end
+
+  it "should print the current scope" do
+    @shell.eval_line("pwd")
+    expect(@shell.output.read).to match(%r{/})
+  end
+  
+end

data/spec/elasticshell/commands/request_parser_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Commands::Request::Parser do
+end

data/spec/elasticshell/commands/request_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Commands::Request do
+
+  before do
+    @shell  = Shell.new(:output => FakeOutput.new, :error => FakeOutput.new, :input => FakeOutput.new )
+    @shell.stub!(:connected?).and_return(true)
+  end
+
+  it "should recognize a simple request" do
+    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "").and_return('{}')
+    @shell.eval_line("_simple")
+  end
+
+  it "should recognize a simple request with a different verb" do
+    @shell.client.should_receive(:request).with("POST", { :op => "/_simple" }, kind_of(Hash), "").and_return('{}')
+    @shell.eval_line("POST _simple")
+  end
+
+  it "should recognize a request with an absolute path" do
+    @shell.client.should_receive(:request).with("GET", { :op => "/some/thing" }, kind_of(Hash), "").and_return('{}')
+    @shell.eval_line("/some/thing")
+  end
+
+  it "should recognize a request with a query string" do
+    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, {"foo" => "bar", "baz" => "booz what", :log => true}, "").and_return('{}')
+    @shell.eval_line("_simple?foo=bar&baz=booz+what")
+  end
+
+  it "should recognize a request with an inline body" do
+    @shell.client.should_receive(:request).with("POST", { :op => "/_simple" }, kind_of(Hash), "{}").and_return('{}')
+    @shell.eval_line("POST _simple {}")
+  end
+
+  it "should recognize a request with a body read from a local file" do
+    File.should_receive(:exist?).with("/some/file.json").and_return(true)
+    File.should_receive(:read).with("/some/file.json").and_return("{}")
+    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "{}").and_return('{}')
+    @shell.eval_line("_simple /some/file.json")
+  end
+
+  it "should recognize a request with a body read from STDIN" do
+    @shell.input_stream.stub!(:gets).and_return("{}")
+    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "{}").and_return('{}')
+    @shell.eval_line("_simple -")
+  end
+
+  it "should be able to pipe the output of a request to Ruby inline" do
+    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "").and_return('{}')
+    @shell.eval_line("_simple | response")
+  end
+
+  it "should be able to pipe the output of a request to a RIPL session" do
+    @shell.client.should_receive(:request).with("GET", { :op => "/_simple" }, kind_of(Hash), "").and_return('{}')
+    require 'ripl'
+    Ripl.should_receive(:start)
+    @shell.eval_line("_simple |")
+  end
+  
+end

data/spec/elasticshell/commands/set_verb_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Commands::SetVerb do
+
+  before do
+    @shell = Shell.new
+  end
+
+  it "set the shell's default verb" do
+    @shell.eval_line("put")
+    expect(@shell.verb).to eql("PUT")
+  end
+
+end

data/spec/elasticshell/scopes_spec.rb

@@ -18,5 +18,84 @@ describe Scopes do
     Scopes::Mapping.should_receive(:new).with(index, 'baz', kind_of(Hash))
     Scopes.from_path("/foobar/baz")
   end
+
+end
+
+describe Scope do
+
+  before do
+    @klass = Class.new(Scope) do
+      def self.requests
+        {
+          "GET" => {
+            '_a1' => "Request a1",
+            '_a2' => "Request a2",
+            'foo' => "Request foo"
+          },
+          "POST" => {
+            '_b'  => "Request b",
+          }
+        }
+      end
+
+      def initial_scopes
+        ["joe", "mary"]
+      end
+
+      def fetch_scopes
+        self.scopes.concat(["sue", "mark"])
+      end
+      
+    end
+    @scope = @klass.new("/path/seg", {})
+  end
+
+  it "should restrict available requests to those matching its current verb" do
+    expect(@scope.requests).to include("_a1", "_a2")
+    @scope.verb = "POST"
+    expect(@scope.requests).to include("_b")
+  end
+
+  it "should reset and fetch new scopes when refreshing, but only once" do
+    @scope.should_receive(:reset!)
+    @scope.should_receive(:fetch_scopes)
+    3.times { @scope.refresh }
+  end
+
+  it "should suggest matches against requests" do
+    expect(@scope.requests_matching('_a')).to eql(['_a1', '_a2'])
+    expect(@scope.requests_matching('f')).to  eql(['foo'])
+    expect(@scope.requests_matching('s')).to  be_empty
+  end
+
+  it "should suggest matches against scopes" do
+    expect(@scope.scopes_matching('j')).to eql(['/path/seg/joe/'])
+    expect(@scope.scopes_matching('m')).to eql(['/path/seg/mary/'])
+  end
+  
+  [
+   %w[ /           /                 _   ],
+   %w[ /foo        /                 foo ],
+   %w[ /foo/       /foo              _   ],
+   %w[ /foo/bar    /foo              bar ],
+   %w[ /foo/bar/   /foo/bar          _   ],
+   %w[ /foo/bar/ba /foo/bar          ba  ],
+   %w[ _           /path/seg/        _   ],
+   %w[ foo         /path/seg/        foo ],
+   %w[ foo/        /path/seg/foo     _   ],
+   %w[ foo/bar     /path/seg/foo     bar ],
+   %w[ foo/bar/    /path/seg/foo/bar _   ],
+   %w[ foo/bar/ba  /path/seg/foo/bar ba  ]
+  ].each do |prefix, completing_scope_path, prefix_within_completing_scope|
+    prefix                         = '' if prefix                         == '_'
+    prefix_within_completing_scope = '' if prefix_within_completing_scope == '_'
+    it "should properly parse the cd-prefix '#{prefix}' into a completion of the scope-prefix '#{prefix_within_completing_scope}' within the scope '#{completing_scope_path}'" do
+      expect(@scope.completing_scope_path_and_prefix(prefix)).to eql([completing_scope_path, prefix_within_completing_scope])
+    end
+  end
+
   
+
 end
+
+  

data/spec/elasticshell/shell_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Shell do
+
+  before do
+    @shell = Shell.new(:output => FakeOutput.new)
+  end
+
+  it "should cache scopes with the same path" do
+    Scopes.should_receive(:from_path).with("/foo", kind_of(Hash))
+    @shell.scope_from_path("/foo")
+  end
+
+  describe "printing output" do
+    
+  end
+  
+end
+

data/spec/elasticshell/utils/has_name_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe HasName do
+
+  before do
+    @obj = Class.new { include HasName }.new
+  end
+
+  it "will not allow setting a name with a space or a '/'" do
+    expect { @obj.name = "I have spaces" }.to raise_error(Elasticshell::ArgumentError)
+    expect { @obj.name = "I have /" }.to      raise_error(Elasticshell::ArgumentError)
+  end
+
+end
+

data/spec/elasticshell/utils/has_verb_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe HasVerb do
+
+  before do
+    @obj = Class.new { include HasVerb }.new
+  end
+
+  it "sets 'GET' as the default verb" do
+    expect(@obj.verb).to eq("GET")
+  end
+
+  it "will allow setting a new verb" do
+    @obj.verb = "POST"
+    expect(@obj.verb).to eq("POST")
+  end
+
+  it "will not allow setting an invalid verb" do
+    @obj.verb = "SUCK"
+    expect(@obj.verb).to eq("GET")
+  end
+  
+end
+