rush2 0.7.0

data/spec/array_ext_spec.rb

@@ -0,0 +1,15 @@
+require_relative 'base'
+
+describe Array do
+	it "mixes commands into array" do
+		[ 1,2,3 ].entries.should == [ 1, 2, 3 ]
+	end
+
+	it "can call head" do
+		[ 1,2,3 ].head(1).should == [ 1 ]
+	end
+
+	it "can call tail" do
+		[ 1,2,3 ].tail(1).should == [ 3 ]
+	end
+end

data/spec/base.rb

@@ -0,0 +1,22 @@
+require 'rspec'
+
+require_relative '../lib/rush'
+
+def mock_config(&block)
+	mock_config_start
+	block.call(config)
+	mock_config_end
+end
+
+def mock_config_sandbox_dir
+	"/tmp/fake_config.#{Process.pid}"
+end
+
+def mock_config_start
+	mock_config_cleanup
+	Rush::Config.new(mock_config_sandbox_dir)
+end
+
+def mock_config_cleanup
+	FileUtils.rm_rf(mock_config_sandbox_dir)
+end

data/spec/box_spec.rb

@@ -0,0 +1,76 @@
+require_relative 'base'
+
+describe Rush::Box do
+	before do
+		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}"
+		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+
+		@box = Rush::Box.new('localhost')
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "looks up entries with [] syntax" do
+		@box['/'].should == Rush::Dir.new('/', @box)
+	end
+
+	it "looks up processes" do
+		@box.connection.should_receive(:processes).and_return([ { :pid => 123 } ])
+		@box.processes.should == [ Rush::Process.new({ :pid => 123 }, @box) ]
+	end
+
+	it "executes bash commands" do
+		@box.connection.should_receive(:bash).with('cmd', nil, false, false).and_return('output')
+		@box.bash('cmd').should == 'output'
+	end
+
+	it "executes bash commands with an optional user" do
+		@box.connection.should_receive(:bash).with('cmd', 'user', false, false)
+		@box.bash('cmd', :user => 'user')
+	end
+
+	it "executes bash commands in the background, returning a Rush::Process" do
+		@box.connection.should_receive(:bash).with('cmd', nil, true, false).and_return(123)
+		@box.stub(:processes).and_return([ double('ps', :pid => 123) ])
+		@box.bash('cmd', :background => true).pid.should == 123
+	end
+
+	it "builds a script of environment variables to prefix the bash command" do
+		@box.command_with_environment('cmd', { :a => 'b' }).should == "export a=\"b\"\ncmd"
+	end
+
+	it "escapes quotes on environment variables" do
+		@box.command_with_environment('cmd', { :a => 'a"b' }).should == "export a=\"a\\\"b\"\ncmd"
+	end
+
+	it "escapes backticks on environment variables" do
+		@box.command_with_environment('cmd', { :a => 'a`b' }).should == "export a=\"a\\\`b\"\ncmd"
+	end
+
+	it "converts environment variables to_s" do
+		@box.command_with_environment('cmd', { :a => nil, :b => 123 }).should == "export a=\"\"\nexport b=\"123\"\ncmd"
+	end
+
+	it "sets the environment variables from the provided hash" do
+		@box.connection.stub(:bash)
+		@box.should_receive(:command_with_environment).with('cmd', { 1 => 2 })
+		@box.bash('cmd', :env => { 1 => 2 })
+	end
+
+	it "checks the connection to determine if it is alive" do
+		@box.connection.should_receive(:alive?).and_return(true)
+		@box.should be_alive
+	end
+
+	it "establish_connection to set up the connection manually" do
+		@box.connection.should_receive(:ensure_tunnel)
+		@box.establish_connection
+	end
+
+	it "establish_connection can take a hash of options" do
+		@box.connection.should_receive(:ensure_tunnel).with(:timeout => :infinite)
+		@box.establish_connection(:timeout => :infinite)
+	end
+end

data/spec/commands_spec.rb

@@ -0,0 +1,47 @@
+require_relative 'base'
+
+describe Rush::Commands do
+	before do
+		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}"
+		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+
+		@filename = "test_file"
+		system "echo thing_to_find > #{@sandbox_dir}/#{@filename}"
+		system "echo dont_find_me > #{@sandbox_dir}/some_other_file"
+
+		@dir = Rush::Dir.new(@sandbox_dir)
+		@array = @dir.files
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "searches a list of files" do
+		results = @dir.files.search(/thing_to_find/)
+		results.should be_kind_of(Rush::SearchResults)
+		results.entries.should == [ @dir[@filename] ]
+		results.lines.should == [ "thing_to_find" ]
+	end
+
+	it "searches a dir" do
+		@dir.search(/thing_to_find/).entries.should == [ @dir[@filename] ]
+	end
+
+	it "searchs a dir's nested files" do
+		@dir.create_dir('sub').create_file('file').write('nested')
+		@dir['**'].search(/nested/).entries.should == [ @dir['sub/file'] ]
+	end
+
+	it "search and replace contents on all files in the glob" do
+		@dir['1'].create.write('xax')
+		@dir['2'].create.write('-a-')
+		@dir.replace_contents!(/a/, 'b')
+		@dir['1'].contents.should == "xbx"
+		@dir['2'].contents.should == "-b-"
+	end
+
+	it "counts lines of the contained files" do
+		@dir.files.line_count.should == 2
+	end
+end

data/spec/config_spec.rb

@@ -0,0 +1,108 @@
+require_relative 'base'
+
+describe Rush::Config do
+	before do
+		@sandbox_dir = "/tmp/rush_config_spec.#{Process.pid}"
+		system "rm -rf #{@sandbox_dir}"
+		@config = Rush::Config.new(@sandbox_dir)
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "creates the dir" do
+		expect(File.directory?(@sandbox_dir)).to eq(true)
+	end
+
+	it "can access the history file" do
+		expect(@config.history_file).to be_kind_of(Rush::File)
+	end
+
+	it "saves the shell command history" do
+		@config.save_history(%w(1 2 3))
+		expect(@config.history_file.contents).to eq("1\n2\n3\n")
+	end
+
+	it "loads the shell command history" do
+		@config.save_history(%w(1 2 3))
+		expect(@config.load_history).to eq(%w(1 2 3))
+	end
+
+	it "loads a blank history if no history file" do
+		expect(@config.load_history).to eq([])
+	end
+
+	it "loads the env file" do
+		@config.env_file.write('abc')
+		expect(@config.load_env).to eq('abc')
+	end
+
+	it "loads nothing if env file does not exist" do
+		expect(@config.load_env).to eq('')
+	end
+
+	it "loads the commands file" do
+		@config.commands_file.write('abc')
+		expect(@config.load_commands).to eq('abc')
+	end
+
+	it "loads nothing if commands file does not exist" do
+		expect(@config.load_commands).to eq('')
+	end
+
+	it "loads usernames and password for rushd" do
+		system "echo 1:2 > #{@sandbox_dir}/passwords"
+		system "echo a:b >> #{@sandbox_dir}/passwords"
+		expect(@config.passwords).to eq({ '1' => '2', 'a' => 'b' })
+	end
+
+	it "loads blank hash if no passwords file" do
+		expect(@config.passwords).to eq({})
+	end
+
+	it "loads credentials for client connecting to server" do
+		system "echo user:pass > #{@sandbox_dir}/credentials"
+		expect(@config.credentials_user).to eq 'user'
+		expect(@config.credentials_password).to eq 'pass'
+	end
+
+	it "loads list of ssh tunnels" do
+		system "echo host.example.com:123 > #{@sandbox_dir}/tunnels"
+		expect(@config.tunnels).to eq({ 'host.example.com' => 123 })
+	end
+
+	it "returns an empty hash if tunnels file is blank" do
+		expect(@config.tunnels).to eq({})
+	end
+
+	it "saves a list of ssh tunnels" do
+		@config.save_tunnels({ 'my.example.com' => 4000 })
+		expect(@config.tunnels_file.contents).to eq "my.example.com:4000\n"
+	end
+
+	it "ensure_credentials_exist doesn't do anything if credentials already exist" do
+		@config.credentials_file.write "dummy"
+		expect(@config).to receive(:generate_credentials).exactly(0).times
+		@config.ensure_credentials_exist
+	end
+
+	it "ensure_credentials_exist generates credentials file if they don't exist" do
+		expect(@config).to receive(:generate_credentials)
+		@config.ensure_credentials_exist
+	end
+
+	it "secret_characters returns valid characters for username or password" do
+		expect(@config.secret_characters).to be_kind_of(Array)
+	end
+
+	it "generate_secret products a random string for use in username and password" do
+		expect(@config).to receive(:secret_characters).and_return(%w(a))
+		expect(@config.generate_secret(2, 2)).to eq "aa"
+	end
+
+	it "generate_credentials saves credentials" do
+		@config.generate_credentials
+		expect(@config.credentials_file.contents).to match(/^.+:.+$/)
+	end
+end

data/spec/dir_spec.rb

@@ -0,0 +1,163 @@
+require_relative 'base'
+
+describe Rush::Dir do
+	before do
+		@sandbox_dir = "/tmp/rush_spec.#{Process.pid}"
+		system "rm -rf #{@sandbox_dir}; mkdir -p #{@sandbox_dir}"
+
+		@dirname = "#{@sandbox_dir}/test_dir/"
+		system "mkdir -p #{@dirname}"
+
+		@dir = Rush::Dir.new(@dirname)
+	end
+
+	after do
+		system "rm -rf #{@sandbox_dir}"
+	end
+
+	it "is a child of Rush::Entry" do
+		expect(@dir).to be_kind_of(Rush::Entry)
+	end
+
+	it "can create itself, returning itself" do
+		system "rm -rf #{@sandbox_dir}"
+		expect(@dir.create).to eq @dir
+		expect(File.directory?(@dir.full_path)).to eq(true)
+	end
+
+	it "can create a new file" do
+		newfile = @dir.create_file('one.txt')
+		expect(newfile.name).to eq 'one.txt'
+		expect(newfile.parent).to eq @dir
+	end
+
+	it "can create a new subdir" do
+		newfile = @dir['two/'].create
+		expect(newfile.name).to eq 'two'
+		expect(newfile.parent).to eq @dir
+	end
+
+	it "find_by_name finds a single entry in the contents" do
+		file = @dir.create_file('one.rb')
+		expect(@dir.find_by_name('one.rb')).to eq file
+	end
+
+	it "find_by_glob finds a list of entries by wildcard" do
+		file1 = @dir.create_file('one.rb')
+		file2 = @dir.create_file('two.txt')
+		expect(@dir.find_by_glob('*.rb')).to eq([file1])
+	end
+
+	it "lists files" do
+		@dir.create_file('a')
+		expect(@dir.files).to eq([Rush::File.new("#{@dirname}/a")])
+	end
+
+	it "lists dirs" do
+		system "mkdir -p #{@dir.full_path}/b"
+		expect(@dir.dirs).to eq([Rush::Dir.new("#{@dirname}/b")])
+	end
+
+	it "lists combined files and dirs" do
+		@dir['c'].create
+		@dir['d/'].create
+		expect(@dir.contents.size).to eq 2
+	end
+
+	it "fetches the entry_tree of all contents recursively" do
+		@dir['a/'].create['b/'].create['c'].create
+		expect(@dir.entries_tree).to eq @dir.make_entries(%w(a/ a/b/ a/b/c))
+	end
+
+	it "maps [] to find_by_name" do
+		expect(@dir).to receive(:find_by_name).once
+		@dir['one']
+	end
+
+	it "maps [] with a wildcard character to find_by_glob" do
+		expect(@dir).to receive(:find_by_glob).once
+		@dir['*']
+	end
+
+	it "can use symbols or strings for [] access" do
+		expect(@dir).to receive(:find_by_name).once.with('subdir')
+		@dir[:subdir]
+	end
+
+	it "[] can return a file that has yet to be created" do
+		expect(@dir['not_yet']).to be_kind_of Rush::File
+	end
+
+	it "makes a list of entries from an array of filenames" do
+		@dir['a'].create
+		@dir['b/c/'].create
+		expect(@dir.make_entries(%w(a b/c))).to eq([ @dir['a'], @dir['b/c'] ])
+	end
+
+	it "lists flattened files from all nested subdirectories" do
+		@dir['1'].create
+		@dir['2/3/'].create['4'].create
+		@dir['a/b/c/'].create['d'].create
+		expect(@dir.files_flattened).to eq @dir.make_entries(%w(1 2/3/4 a/b/c/d))
+	end
+
+	it "lists flattened dirs from all nested subdirectories" do
+		@dir.create_dir('1/2')
+		expect(@dir.dirs_flattened).to eq @dir.make_entries(%w(1/ 1/2/))
+	end
+
+	it "** as a shortcut to flattened_files" do
+		expect(@dir['**']).to eq @dir.files_flattened
+	end
+
+	it "**/ as a shortcut to flattened_files + regular globbing" do
+		@dir.create_file('1.rb')
+		@dir.create_file('ignore.txt')
+		@dir.create_dir('2').create_file('3.rb')
+		@dir.create_dir('a/b').create_file('c.rb')
+		expect(@dir['**/*.rb']).to eq @dir.make_entries(%w(1.rb 2/3.rb a/b/c.rb))
+	end
+
+	it "lists nonhidden files" do
+		@dir.create_file('show')
+		@dir.create_file('.dont_show')
+		expect(@dir.nonhidden_files).to eq @dir.make_entries(%(show))
+	end
+
+	it "lists nonhidden dirs" do
+		@dir.create_dir('show')
+		@dir.create_dir('.dont_show')
+		expect(@dir.nonhidden_dirs).to eq @dir.make_entries(%(show/))
+	end
+
+	if !RUBY_PLATFORM.match(/darwin/)   # doesn't work on OS X 'cause du switches are different
+		it "knows its size in bytes, which includes its contents recursively" do
+			@dir.create_file('a').write('1234')
+			expect(@dir.size).to eq(4096 + 4)
+		end
+	end
+
+	it "can destroy itself when empty" do
+		@dir.destroy
+	end
+
+	it "can destroy itself when not empty" do
+		@dir.create_dir('a').create_file('b').write('c')
+		@dir.destroy
+	end
+
+	it "can run a bash command within itself" do
+		system "echo test > #{@dir.full_path}/file"
+		expect(@dir.bash("cat file")).to eq "test\n"
+	end
+
+	it "can run bash within directories with spaces" do
+		@dir.create_dir('with space').create_file('file').write('test')
+		expect(@dir["with space/"].bash("cat file")).to eq "test"
+	end
+
+	it "passes bash options (e.g., :user) through to the box bash command" do
+		expect(@dir).to receive(:bash).with('cmd', :opt1 => 1, :opt2 => 2)
+		@dir.bash('cmd', :opt1 => 1, :opt2 => 2)
+	end
+end

data/spec/embeddable_shell_spec.rb

@@ -0,0 +1,17 @@
+require_relative 'base'
+
+describe Rush::EmbeddableShell do
+	before do
+		@shell = Rush::EmbeddableShell.new
+	end
+
+	it "should execute unknown methods against a Rush::Shell instance" do
+		@shell.root.class.should == Rush::Dir
+	end
+
+	it "should executes a block as if it were inside the shell" do
+		@shell.execute_in_shell {
+			root.class.should == Rush::Dir
+		}
+	end
+end