rush2 0.7.1 → 0.8.0

data/spec/process_set_spec.rb

@@ -1,50 +1,50 @@
 require_relative 'base'
 
 describe Rush::ProcessSet do
-	before do
-		@process = double('process')
-		@set = Rush::ProcessSet.new([ @process ])
-	end
-
-	it "is Enumerable" do
-		@set.select { |s| s == @process }.should == [ @process ]
-	end
-
-	it "defines size" do
-		@set.size.should == 1
-	end
-
-	it "defines first" do
-		@set.first.should == @process
-	end
-
-	it "is equal to sets with the same contents" do
-		@set.should == Rush::ProcessSet.new([ @process ])
-	end
-
-	it "is equal to arrays with the same contents" do
-		@set.should == [ @process ]
-	end
-
-	it "kills all processes in the set" do
-		@process.should_receive(:kill)
-		@set.kill
-	end
-
-	it "checks the alive? state of all processes in the set" do
-		@process.should_receive(:alive?).and_return(true)
-		@set.alive?.should == [ true ]
-	end
-
-	it "filters the set from a conditions hash and returns the filtered set" do
-		@process.stub(:pid).and_return(123)
-		@set.filter(:pid => 123).first.should == @process
-		@set.filter(:pid => 456).size.should == 0
-	end
-
-	it "filters with regexps if provided in the conditions" do
-		@process.stub(:command).and_return('foobaz')
-		@set.filter(:command => /baz/).first.should == @process
-		@set.filter(:command => /blerg/).size.should == 0
-	end
+  before do
+    @process = double('process')
+    @set = Rush::ProcessSet.new([ @process ])
+  end
+
+  it "is Enumerable" do
+    expect(@set.select { |s| s == @process }).to eq [ @process ]
+  end
+
+  it "defines size" do
+    expect(@set.size).to eq 1
+  end
+
+  it "defines first" do
+    expect(@set.first).to eq @process
+  end
+
+  it "is equal to sets with the same contents" do
+    expect(@set).to eq Rush::ProcessSet.new([ @process ])
+  end
+
+  it "is equal to arrays with the same contents" do
+    expect(@set).to eq [ @process ]
+  end
+
+  it "kills all processes in the set" do
+    expect(@process).to receive(:kill)
+    @set.kill
+  end
+
+  it "checks the alive? state of all processes in the set" do
+    expect(@process).to receive(:alive?).and_return(true)
+    expect(@set.alive?).to eq [ true ]
+  end
+
+  it "filters the set from a conditions hash and returns the filtered set" do
+    allow(@process).to receive(:pid).and_return(123)
+    expect(@set.filter(:pid => 123).first).to eq @process
+    expect(@set.filter(:pid => 456).size).to eq 0
+  end
+
+  it "filters with regexps if provided in the conditions" do
+    allow(@process).to receive(:command).and_return('foobaz')
+    expect(@set.filter(:command => /baz/).first).to eq @process
+    expect(@set.filter(:command => /blerg/).size).to eq 0
+  end
 end

data/spec/process_spec.rb

@@ -1,73 +1,75 @@
 require_relative 'base'
 
 describe Rush::Process do
-	before do
-		@pid = fork do
-			sleep 999
-		end
-		@process = Rush::Process.all.detect { |p| p.pid == @pid }
-	end
+  before do
+    @pid = fork do
+      sleep 999
+    end
+    @process = Rush::Process.all.detect { |p| p.pid == @pid }
+  end
 
-	after do
-		system "kill -9 #{@pid}"
-	end
+  after do
+    system "kill -9 #{@pid}"
+  end
 
-	if !RUBY_PLATFORM.match(/darwin/)   # OS x reports pids weird
-		it "knows all its child processes" do
-			parent = Rush::Process.all.detect { |p| p.pid == Process.pid }
-			parent.children.should == [ @process ]
-		end
-	end
+  unless RUBY_PLATFORM.match(/darwin/)   # OS x reports pids weird
+    it 'knows all its child processes' do
+      parent = Rush::Process.all.detect { |p| p.pid == Process.pid }
+      expect(parent.children).to eq [@process]
+    end
+  end
 
-	it "gets the list of all processes" do
-		list = Rush::Process.all
-		list.size.should > 5
-		list.first.should be_kind_of(Rush::Process)
-	end
+  it 'gets the list of all processes' do
+    list = Rush::Process.all
+    expect(list.size).to be > 5
+    expect(list.first).to be_kind_of Rush::Process
+  end
 
-	it "knows the pid" do
-		@process.pid.should == @pid
-	end
+  it 'knows the pid' do
+    expect(@process.pid).to eq @pid
+  end
 
-	it "knows the uid" do
-		@process.uid.should == ::Process.uid
-	end
+  it 'knows the uid' do
+    expect(@process.uid).to eq ::Process.uid
+  end
 
-	it "knows the executed binary" do
-		@process.command.should match(/(ruby|rbx)/)
-	end
+  it 'knows the executed binary' do
+    expect(@process.command).to match(/(ruby|rbx)/)
+  end
 
-	it "knows the command line" do
-		@process.cmdline.should match(/process_spec.rb/)
-	end
+  it 'knows the command line' do
+    expect(@process.cmdline).to match(/rspec/)
+  end
 
-	it "knows the memory used" do
-		@process.mem.should > 0
-	end
+  it 'knows the memory used' do
+    expect(@process.mem).to be > 0
+  end
 
-	it "knows the cpu used" do
-		@process.cpu.should >= 0
-	end
+  it 'knows the cpu used' do
+    expect(@process.cpu).to be >= 0
+  end
 
-	it "knows the parent process pid" do
-		@process.parent_pid.should == Process.pid
-	end
+  it 'knows the parent process pid' do
+    expect(@process.parent_pid).to eq Process.pid
+  end
 
-	it "knows the parent process" do
-		this = Rush::Box.new.processes.select { |p| p.pid == Process.pid }.first
-		@process.parent.should == this
-	end
+  it 'knows the parent process' do
+    this = Rush::Box.new.processes
+      .select { |p| p.pid == Process.pid }
+      .first
+    expect(@process.parent).to eq this
+  end
 
-	it "can kill itself" do
-		process = Rush.bash("sleep 30", :background => true)
-		process.alive?.should be_true
-		process.kill
-		sleep 0.1
-		process.alive?.should be_false
-	end
+  it 'can kill itself' do
+    process = Rush.bash('sleep 30', background: true)
+    expect(process.alive?).to eq true
+    process.kill
+    sleep 0.1
+    expect(process.alive?).to eq false
+  end
 
-	it "if box and pid are the same, process is equal" do
-		other = Rush::Process.new({ :pid => @process.pid }, @process.box)
-		@process.should == other
-	end
+  it 'if box and pid are the same, process is equal' do
+    other = Rush::Process.new({ pid: @process.pid }, @process.box)
+    expect(@process).to eq other
+  end
 end

data/spec/rush_spec.rb

@@ -1,28 +1,28 @@
 require_relative 'base'
 
 describe Rush do
-	it "fetches a local file path" do
-		Rush['/etc/hosts'].full_path.should == '/etc/hosts'
-	end
+  it 'fetches a local file path' do
+    expect(Rush['/etc/hosts'].full_path).to eq('/etc/hosts')
+  end
 
-	it "fetches the dir of __FILE__" do
-		Rush.dir(__FILE__).name.should == 'spec'
-	end
+  it 'fetches the dir of __FILE__' do
+    expect(Rush.dir(__FILE__).name).to eq('spec')
+  end
 
-	it "fetches the launch dir (aka current working directory or pwd)" do
-		Dir.stub(:pwd).and_return('/tmp')
-		Rush.launch_dir.should == Rush::Box.new['/tmp/']
-	end
+  it 'fetches the launch dir (aka current working directory or pwd)' do
+    allow(Dir).to receive(:pwd).and_return('/tmp')
+    expect(Rush.launch_dir).to eq(Rush::Box.new['/tmp/'])
+  end
 
-	it "runs a bash command" do
-		Rush.bash('echo hi').should == "hi\n"
-	end
+  it 'runs a bash command' do
+    expect(Rush.bash('echo hi')).to eq("hi\n")
+  end
 
-	it "gets the list of local processes" do
-		Rush.processes.should be_kind_of(Rush::ProcessSet)
-	end
+  it 'gets the list of local processes' do
+    expect(Rush.processes).to be_kind_of(Rush::ProcessSet)
+  end
 
-	it "gets my process" do
-		Rush.my_process.pid.should == Process.pid
-	end
+  it 'gets my process' do
+    expect(Rush.my_process.pid).to eq(Process.pid)
+  end
 end

data/spec/shell_spec.rb

@@ -23,7 +23,7 @@ describe Rush::Shell do
  it 'Complete method names' do
    expect(@shell.complete('Rush.meth')).
      to eq(["Rush.method_part", "Rush.method_defined?", "Rush.methods", "Rush.method"])
-   expect(@shell.complete('Rush.methods.inc')).to eq ["Rush.methods.include?"]
+   expect(@shell.complete('Rush.methods.inc')).to include "Rush.methods.include?"
  end
 
  it 'Complete paths' do

data/spec/ssh_tunnel_spec.rb

@@ -1,122 +1,122 @@
-require_relative 'base'
-
-describe Rush::SshTunnel do
-	before do
-		@tunnel = Rush::SshTunnel.new('spec.example.com')
-		@tunnel.stub(:config).and_return(mock_config_start)
-		@tunnel.stub(:display)
-	end
-
-	after do
-		mock_config_cleanup
-	end
-
-	it "ensure_tunnel sets everything up for the tunnel when one does not already exist" do
-		@tunnel.should_receive(:push_credentials)
-		@tunnel.should_receive(:launch_rushd)
-		@tunnel.should_receive(:establish_tunnel)
-		@tunnel.ensure_tunnel
-	end
-
-	it "ensure_tunnel uses the existing port as long as the tunnel is still alive" do
-		@tunnel.should_receive(:tunnel_alive?).and_return(true)
-		@tunnel.instance_eval("@port = 2345")
-		@tunnel.ensure_tunnel
-		@tunnel.port.should == 2345
-	end
-
-	it "existing tunnel is used when it is specified in the tunnels file" do
-		@tunnel.config.tunnels_file.write "spec.example.com:4567\n"
-		@tunnel.should_receive(:tunnel_alive?).and_return(true)
-		@tunnel.should_not_receive(:setup_everything)
-		@tunnel.ensure_tunnel
-		@tunnel.port.should == 4567
-	end
-
-	it "tunnel host is always local" do
-		@tunnel.host.should == 'localhost'
-	end
-
-	it "picks the first port number when there are no tunnels yet" do
-		@tunnel.next_available_port.should == 7771
-	end
-
-	it "picks the next port number when there is already a tunnel" do
-		@tunnel.config.tunnels_file.write("#{@tunnel.host}:7771")
-		@tunnel.next_available_port.should == 7772
-	end
-
-	it "establishes a tunnel and saves it to ~/.rush/tunnels" do
-		@tunnel.should_receive(:make_ssh_tunnel)
-		@tunnel.should_receive(:port).exactly(0).times
-		@tunnel.establish_tunnel
-		@tunnel.config.tunnels_file.contents.should == "spec.example.com:7771\n"
-	end
-
-	it "converts instance vars to options hash for ssh_tunnel_command" do
-		@tunnel.instance_eval("@port = 1234")
-		@tunnel.tunnel_options.should == {
-			:local_port => 1234,
-			:remote_port => 7770,
-			:ssh_host => 'spec.example.com'
-		}
-	end
-
-	it "ssh_stall_command uses an infinite loop for :timeout => :infinite" do
-		@tunnel.ssh_stall_command(:timeout => :infinite).should match(/while .* sleep .* done/)
-	end
-
-	it "ssh_stall_command sleeps for the number of seconds given as the :timeout option" do
-		@tunnel.ssh_stall_command(:timeout => 123).should == "sleep 123"
-	end
-
-	it "ssh_stall_command uses the default timeout when no options are given" do
-		@tunnel.ssh_stall_command.should == "sleep 9000"
-	end
-
-	it "constructs the ssh tunnel command (everything but stall) from the options hash" do
-		@tunnel.should_receive(:tunnel_options).at_least(:once).and_return(
-			:local_port => 123,
-			:remote_port => 456,
-			:ssh_host => 'example.com'
-		)
-		@tunnel.ssh_tunnel_command_without_stall.should == "ssh -f -L 123:127.0.0.1:456 example.com"
-	end
-
-	it "combines the tunnel command without stall and the stall command into the final command" do
-		@tunnel.should_receive(:ssh_tunnel_command_without_stall).and_return('ssh command')
-		@tunnel.should_receive(:ssh_stall_command).and_return('sleep 123')
-		@tunnel.ssh_tunnel_command.should == 'ssh command "sleep 123"'
-	end
-
-	it "ssh_tunnel_command request that the port be set" do
-		@tunnel.should_receive(:tunnel_options).at_least(:once).and_return(:local_port => nil)
-		lambda { @tunnel.ssh_tunnel_command }.should raise_error(Rush::SshTunnel::NoPortSelectedYet)
-	end
-
-
-	it "push_credentials uses ssh to append to remote host's passwords file" do
-		@tunnel.should_receive(:ssh_append_to_credentials).and_return(true)
-		@tunnel.push_credentials
-	end
-
-	it "launches rushd on the remote host via ssh" do
-		@tunnel.should_receive(:ssh) do |cmd|
-			cmd.should match(/rushd/)
-		end
-		@tunnel.launch_rushd
-	end
-
-	it "tunnel_alive? checks whether a tunnel is still up" do
-		@tunnel.should_receive(:tunnel_count_command).and_return("echo 1")
-		@tunnel.tunnel_alive?.should be_true
-	end
-
-	it "tunnel_count_command greps ps to find the ssh tunnel" do
-		@tunnel.should_receive(:ssh_tunnel_command_without_stall).and_return('ssh command')
-		command = @tunnel.tunnel_count_command
-		command.should match(/ps/)
-		command.should match(/grep/)
-		command.should match(/ssh command/)
-	end
-end
+# require_relative 'base'
+#
+# describe Rush::SshTunnel do
+# 	before do
+# 		@tunnel = Rush::SshTunnel.new('spec.example.com')
+# 		@tunnel.stub(:config).and_return(mock_config_start)
+# 		@tunnel.stub(:display)
+# 	end
+#
+# 	after do
+# 		mock_config_cleanup
+# 	end
+#
+# 	it "ensure_tunnel sets everything up for the tunnel when one does not already exist" do
+# 		@tunnel.should_receive(:push_credentials)
+# 		@tunnel.should_receive(:launch_rushd)
+# 		@tunnel.should_receive(:establish_tunnel)
+# 		@tunnel.ensure_tunnel
+# 	end
+#
+# 	it "ensure_tunnel uses the existing port as long as the tunnel is still alive" do
+# 		@tunnel.should_receive(:tunnel_alive?).and_return(true)
+# 		@tunnel.instance_eval("@port = 2345")
+# 		@tunnel.ensure_tunnel
+# 		@tunnel.port.should == 2345
+# 	end
+#
+# 	it "existing tunnel is used when it is specified in the tunnels file" do
+# 		@tunnel.config.tunnels_file.write "spec.example.com:4567\n"
+# 		@tunnel.should_receive(:tunnel_alive?).and_return(true)
+# 		@tunnel.should_not_receive(:setup_everything)
+# 		@tunnel.ensure_tunnel
+# 		@tunnel.port.should == 4567
+# 	end
+#
+# 	it "tunnel host is always local" do
+# 		@tunnel.host.should == 'localhost'
+# 	end
+#
+# 	it "picks the first port number when there are no tunnels yet" do
+# 		@tunnel.next_available_port.should == 7771
+# 	end
+#
+# 	it "picks the next port number when there is already a tunnel" do
+# 		@tunnel.config.tunnels_file.write("#{@tunnel.host}:7771")
+# 		@tunnel.next_available_port.should == 7772
+# 	end
+#
+# 	it "establishes a tunnel and saves it to ~/.rush/tunnels" do
+# 		@tunnel.should_receive(:make_ssh_tunnel)
+# 		@tunnel.should_receive(:port).exactly(0).times
+# 		@tunnel.establish_tunnel
+# 		@tunnel.config.tunnels_file.contents.should == "spec.example.com:7771\n"
+# 	end
+#
+# 	it "converts instance vars to options hash for ssh_tunnel_command" do
+# 		@tunnel.instance_eval("@port = 1234")
+# 		@tunnel.tunnel_options.should == {
+# 			:local_port => 1234,
+# 			:remote_port => 7770,
+# 			:ssh_host => 'spec.example.com'
+# 		}
+# 	end
+#
+# 	it "ssh_stall_command uses an infinite loop for :timeout => :infinite" do
+# 		@tunnel.ssh_stall_command(:timeout => :infinite).should match(/while .* sleep .* done/)
+# 	end
+#
+# 	it "ssh_stall_command sleeps for the number of seconds given as the :timeout option" do
+# 		@tunnel.ssh_stall_command(:timeout => 123).should == "sleep 123"
+# 	end
+#
+# 	it "ssh_stall_command uses the default timeout when no options are given" do
+# 		@tunnel.ssh_stall_command.should == "sleep 9000"
+# 	end
+#
+# 	it "constructs the ssh tunnel command (everything but stall) from the options hash" do
+# 		@tunnel.should_receive(:tunnel_options).at_least(:once).and_return(
+# 			:local_port => 123,
+# 			:remote_port => 456,
+# 			:ssh_host => 'example.com'
+# 		)
+# 		@tunnel.ssh_tunnel_command_without_stall.should == "ssh -f -L 123:127.0.0.1:456 example.com"
+# 	end
+#
+# 	it "combines the tunnel command without stall and the stall command into the final command" do
+# 		@tunnel.should_receive(:ssh_tunnel_command_without_stall).and_return('ssh command')
+# 		@tunnel.should_receive(:ssh_stall_command).and_return('sleep 123')
+# 		@tunnel.ssh_tunnel_command.should == 'ssh command "sleep 123"'
+# 	end
+#
+# 	it "ssh_tunnel_command request that the port be set" do
+# 		@tunnel.should_receive(:tunnel_options).at_least(:once).and_return(:local_port => nil)
+# 		lambda { @tunnel.ssh_tunnel_command }.should raise_error(Rush::SshTunnel::NoPortSelectedYet)
+# 	end
+#
+#
+# 	it "push_credentials uses ssh to append to remote host's passwords file" do
+# 		@tunnel.should_receive(:ssh_append_to_credentials).and_return(true)
+# 		@tunnel.push_credentials
+# 	end
+#
+# 	it "launches rushd on the remote host via ssh" do
+# 		@tunnel.should_receive(:ssh) do |cmd|
+# 			cmd.should match(/rushd/)
+# 		end
+# 		@tunnel.launch_rushd
+# 	end
+#
+# 	it "tunnel_alive? checks whether a tunnel is still up" do
+# 		@tunnel.should_receive(:tunnel_count_command).and_return("echo 1")
+# 		@tunnel.tunnel_alive?.should be_true
+# 	end
+#
+# 	it "tunnel_count_command greps ps to find the ssh tunnel" do
+# 		@tunnel.should_receive(:ssh_tunnel_command_without_stall).and_return('ssh command')
+# 		command = @tunnel.tunnel_count_command
+# 		command.should match(/ps/)
+# 		command.should match(/grep/)
+# 		command.should match(/ssh command/)
+# 	end
+# end