ruby-virtualenv 0.5.0

data/lib/sandbox/templates/activate.erb

@@ -0,0 +1,97 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+forget_cached_commands () {
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "$BASH" -o -n "$ZSH_VERSION" ] ; then
+        hash -r
+    fi
+
+}
+
+deactivate () {
+
+    if [ -n "$_OLD_SANDBOX_GEM_HOME" ] ; then
+        GEM_HOME="$_OLD_SANDBOX_GEM_HOME"
+        export GEM_HOME
+    else
+        unset GEM_HOME
+    fi
+
+    if [ -n "$_OLD_SANDBOX_GEM_PATH" ] ; then
+        GEM_PATH="$_OLD_SANDBOX_GEM_PATH"
+        export GEM_PATH
+    else
+        unset GEM_PATH
+    fi
+
+    if [ -n "$_OLD_SANDBOX_PATH" ] ; then
+        PATH="$_OLD_SANDBOX_PATH"
+        export PATH
+    fi
+
+    if [ -n "$_OLD_SANDBOX_HOME" ] ; then
+        HOME="$_OLD_SANDBOX_HOME"
+        export HOME
+    fi
+
+    if [ -n "$_OLD_SANDBOX_PS1" ] ; then
+        PS1="$_OLD_SANDBOX_PS1"
+        export PS1
+    fi
+
+    unset _OLD_SANDBOX_PATH
+    unset _OLD_SANDBOX_HOME
+    unset _OLD_SANDBOX_GEM_HOME
+    unset _OLD_SANDBOX_GEM_PATH
+    unset _OLD_SANDBOX_PS1
+    unset SANDBOX_ENV
+
+    forget_cached_commands
+
+    if [ ! "$1" = "nondestructive" ] ; then
+        # Self destruct!
+        unset deactivate
+        unset forget_cached_commands
+    fi
+}
+
+activate () {
+
+    # unset irrelavent variables
+    deactivate nondestructive
+
+    # preserve current variables
+    _OLD_SANDBOX_GEM_HOME="$GEM_HOME"
+    _OLD_SANDBOX_GEM_PATH="$GEM_PATH"
+    _OLD_SANDBOX_PATH="$PATH"
+    _OLD_SANDBOX_HOME="$HOME"
+    _OLD_SANDBOX_PS1="$PS1"
+
+    # set the sandbox-aware states
+    SANDBOX_ENV="<%= target %>"
+    PATH="$SANDBOX_ENV/bin:$PATH"
+    HOME="$SANDBOX_ENV"
+    GEM_HOME="$SANDBOX_ENV/rubygems"
+    GEM_PATH="$GEM_HOME"
+    if [ "`basename \"$SANDBOX_ENV\"`" = "__" ] ; then
+        # special case for Aspen magic directories
+        # see http://www.zetadev.com/software/aspen/
+        PS1="[ruby-virtualenv:`basename \`dirname \"$SANDBOX_ENV\"\``] $PS1"
+    else
+        PS1="(ruby-virtualenv:`basename \"$SANDBOX_ENV\"`) $PS1"
+    fi
+
+    export SANDBOX_ENV PATH HOME GEM_HOME GEM_PATH PS1
+
+    forget_cached_commands
+
+    unset activate
+}
+
+activate
+
+# Thanks to the virtualenv developers (http://pypi.python.org/pypi/virtualenv)

data/lib/sandbox/templates/gemrc.erb

@@ -0,0 +1,7 @@
+--- 
+:benchmark: false
+:update_sources: true
+:bulk_threshold: 1000
+:verbose: true
+:backtrace: false
+gem: --no-ri --no-rdoc

data/lib/sandbox/version.rb

@@ -0,0 +1,3 @@
+module Sandbox
+  VERSION = "0.5.0"
+end

data/ruby-virtualenv.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sandbox/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jacob Radford", "Francesc Esplugas"]
+  gem.email         = ["nkryptic@gmail.com", "francesc.esplugas@gmail.com"]
+  gem.description   = %q{Create virtual ruby/rubygems environments.}
+  gem.summary       = %q{Create virtual ruby/rubygems environments.}
+  gem.homepage      = "http://github.com/fesplugas/ruby-virtualenv"
+
+  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          = "ruby-virtualenv"
+  gem.require_paths = ["lib"]
+  gem.version       = Sandbox::VERSION
+
+  gem.add_development_dependency "rspec", "~> 2.6.0"
+  gem.add_development_dependency "mocha", "~> 0.10.0"
+end

data/spec/sandbox/cli_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+require 'sandbox/cli'
+
+describe Sandbox::CLI do
+  
+  it "should raise an error when running from a loaded sandbox" do
+    begin
+      ENV[ 'SANDBOX' ] = 'something'
+      lambda { Sandbox::CLI.verify_environment! }.should raise_error( Sandbox::LoadedSandboxError )
+    ensure
+      ENV[ 'SANDBOX' ] = nil
+    end
+  end
+  
+  describe "calling execute" do
+    before( :each ) do
+      @instance = stub_everything()
+    end
+    
+    it "should handle all errors" do
+      Sandbox::CLI.stubs( :new ).raises( StandardError )
+      Sandbox::CLI.expects( :handle_error ).with( instance_of( StandardError ) )
+      Sandbox::CLI.execute
+    end
+    
+    it "should attempt to parse ARGV by default" do
+      Sandbox::CLI.expects( :parse ).with( ARGV ).returns( @instance )
+      Sandbox::CLI.execute
+    end
+    
+    it "should create a new instance" do
+      Sandbox::CLI.expects( :new ).returns( @instance )
+      Sandbox::CLI.execute
+    end
+    
+    it "should call parse_args! on the new instance" do
+      @instance.expects( :parse_args! )
+      Sandbox::CLI.expects( :new ).returns( @instance )
+      Sandbox::CLI.execute
+    end
+    
+    it "should run the instance" do
+      @instance.expects( :execute! )
+      Sandbox::CLI.expects( :parse ).returns( @instance )
+      Sandbox::CLI.execute
+    end
+  end
+  
+  describe "handling errors" do
+    it "should just print Sandbox::Error message" do
+      err = Sandbox::Error.new( "spec test msg" )
+      Sandbox::CLI.expects( :tell_unless_really_quiet ).once.with( regexp_matches( /^Sandbox error: spec test msg/ ) )
+      Sandbox::CLI.handle_error( err )
+    end
+    
+    it "should just print wrapped StandardError message" do
+      err = StandardError.new( "spec test msg" )
+      Sandbox::CLI.expects( :tell_unless_really_quiet ).once.with( regexp_matches( /^Error: spec test msg/ ) )
+      Sandbox::CLI.handle_error( err )
+    end
+    
+    it "should have simple message for Interrupt" do
+      err = Interrupt.new( "spec test msg" )
+      Sandbox::CLI.expects( :tell_unless_really_quiet ).once.with( 'Interrupted' )
+      Sandbox::CLI.handle_error( err )
+    end
+    
+    it "should reraise other errors" do
+      err = NotImplementedError.new( 'you should have implemented it, dummy' )
+      Sandbox::CLI.expects( :raise ).once.with( err )
+      Sandbox::CLI.handle_error( err )
+    end
+  end
+  
+  describe "a new instance" do
+    
+    before( :each ) do
+      @cli = Sandbox::CLI.new
+    end
+    
+    it "should have no default 'gems to install'" do
+      @cli.options[ :gems ].should == []
+    end
+    
+    describe "instance calling parse_args!" do
+      def processor( *args ); lambda { @cli.parse_args!( args ) }; end
+      def process( *args ); processor( *args ).call; end
+  
+      describe "using NO arguments" do
+        it "should use raise nothing" do
+          process()
+          @cli.options[ :original_args ].should == []
+          @cli.options[ :args ].should == []
+        end
+      end
+  
+      describe "using VALID arguments" do
+        [ '-V', '--version' ].each do |arg|
+          it "should print the version for switch '#{arg}'" do
+            @cli.expects( :tell_unless_really_quiet ).with( Sandbox::VERSION )
+            processor( arg ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+          end
+        end
+          
+        [ '-V', '--version' ].each do |arg|
+          it "should ignore additional arguments after '#{arg}'" do
+            # @cli.stubs(:puts)
+            @cli.expects( :tell_unless_really_quiet ).with( Sandbox::VERSION ).times(2)
+            processor( arg, '-x' ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+            processor( arg, 'unknown' ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+          end
+        end
+          
+        [ '-h', '--help' ].each do |arg|
+          it "should show help for '#{arg}'" do
+            @cli.expects( :tell_unless_really_quiet ).with( instance_of( OptionParser ) )
+            processor( arg ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+          end
+        end
+          
+        [ '-h', '--help' ].each do |arg|
+          it "should ignore additional arguments after '#{arg}'" do
+            @cli.expects( :tell_unless_really_quiet ).with( instance_of( OptionParser ) ).times(2)
+            processor( arg, '-x' ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+            processor( arg, 'unknown' ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+          end
+        end
+        
+        [ '-H', '--long-help' ].each do |arg|
+          it "should show long help for '#{arg}'" do
+            @cli.expects( :tell_unless_really_quiet )
+            @cli.expects( :long_help )
+            processor( arg ).should raise_error( SystemExit ) { |error| error.status.should == 0 }
+          end
+        end
+          
+        [ '-v', '--verbose' ].each do |arg|
+          it "should increase verbosity with '#{arg}'" do
+            Sandbox.expects( :increase_verbosity )
+            process( arg )
+            @cli.options[ :original_args ].should == [ arg ]
+            @cli.options[ :args ].should == []
+          end
+        end
+        
+        [ [ '-v', '-v' ], [ '--verbose', '--verbose' ] ].each do |args|
+          it "should increase verbosity twice with '#{args.join(' ')}'" do
+            Sandbox.expects( :increase_verbosity ).times(2)
+            process( *args )
+            @cli.options[ :original_args ].should == args
+            @cli.options[ :args ].should == []
+          end
+        end
+        
+        it "should require additional arguments with switch '-g'" do
+          processor( '-g' ).should raise_error( Sandbox::ParseError )
+        end
+        
+        it "should set 'gems to install' with switch '-g'" do
+          args = [ '-g', 'somegem,anothergem' ]
+          process( *args )
+          @cli.options[ :original_args ].should == args
+          @cli.options[ :args ].should == []
+          @cli.options[ :gems ].should == [ 'somegem', 'anothergem' ]
+        end
+        
+        it "should clear 'gems to install' with switch '-n'" do
+          process( '-n' )
+          @cli.options[ :original_args ].should == [ '-n' ]
+          @cli.options[ :args ].should == []
+          @cli.options[ :gems ].should == []
+        end
+        
+        it "should store leftover arguments in options for arguments '/path/to/somewhere'" do
+          args = [ '/path/to/somewhere' ]
+          process( *args )
+          @cli.options[ :original_args ].should == args
+          @cli.options[ :args ].should == args
+        end
+        
+        it "should store leftover arguments in options for arguments '-v /path/to/somewhere'" do
+          args = [ '-v', '/path/to/somewhere' ]
+          process( *args )
+          @cli.options[ :original_args ].should == args
+          @cli.options[ :args ].should == [ args.last ]
+        end
+      end
+  
+      describe "using INVALID arguments" do
+        it "should exit with message for invalid switch '-x'" do
+          processor( '-x' ).
+              should raise_error( Sandbox::ParseError ) { |error| error.message.should =~ /-x\b/ }
+        end
+      end
+    end
+    
+    describe "instance calling execute!" do
+      def processor; lambda { @cli.execute! }; end
+      def process; processor.call; end
+      
+      it "should raise error with no target specified" do
+        @cli.options[ :args ] = []
+        processor.should raise_error
+      end
+      
+      it "should raise error with more than one target" do
+        @cli.options[ :args ] = [ 'one', 'two' ]
+        processor.should raise_error
+      end
+      
+      it "should instantiate an Installer and call populate with one target" do
+        @cli.options.delete( :gems )
+        @cli.options[ :args ] = [ 'one' ]
+        installer = mock( 'Installer', :populate )
+        Sandbox::Installer.expects( :new ).with( { :target => 'one' } ).returns( installer )
+        process
+      end
+      
+    end
+    
+    describe "instance calling long_help" do
+      it "should return a long descriptive string" do
+        @cli.long_help.split( "\n" ).size.should be > 20
+        @cli.long_help.should =~ /activate/
+        @cli.long_help.should =~ /deactivate/
+        @cli.long_help.should =~ /NOTES:/
+        @cli.long_help.should =~ /WARNINGS:/
+      end
+    end
+    
+  end
+  
+end
+

data/spec/sandbox/errors_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'new', Sandbox::Error do
+  it "should wrap it's message with 'Sandbox error'" do
+    Sandbox::Error.new( 'msg' ).message.should == 'Sandbox error: msg'
+  end
+end
+
+describe 'new', Sandbox::LoadedSandboxError do
+  it "should have informative default msg" do
+    Sandbox::LoadedSandboxError.new.message.should =~ /loaded sandbox/
+  end
+end
+
+describe 'new', Sandbox::ParseError do
+  it "should accept reason with array" do
+    Sandbox::ParseError.new( 'testing', [ 1, 2, 3, 4 ] ).
+        message.should =~ /testing => 1 2 3 4/
+  end
+
+  it "should accept reason with string" do
+    Sandbox::ParseError.new( 'testing', "1, 2, 3, 4" ).
+        message.should =~ /testing => 1, 2, 3, 4/
+  end
+
+  it "should fall back to reason alone" do
+    Sandbox::ParseError.new( 'testing', [] ).
+        message.should =~ /testing$/
+    Sandbox::ParseError.new( 'testing', '' ).
+        message.should =~ /testing$/
+  end
+end

data/spec/sandbox/installer_spec.rb

@@ -0,0 +1,303 @@
+require 'spec_helper'
+
+describe Sandbox::Installer, "(mocked)" do
+  
+  before( :each ) do
+    Sandbox.instance_eval { instance_variables.each { |v| remove_instance_variable v } }
+  end
+  
+  describe "creating an instance" do
+    # initialize( options={} )
+    it "should set it's options" do
+      opts = { :somewhere => true, :nowhere => false }
+      installer = Sandbox::Installer.new( opts )
+      installer.options[ :somewhere ].should be_true
+      installer.options[ :nowhere ].should be_false
+    end
+  end
+  
+  describe "instance" do
+    # target
+    describe "when target called" do
+      it "should validate target directory once" do
+        path = '/some/new/target'
+        opts = { :target => path }
+        @installer = Sandbox::Installer.new( opts )
+        @installer.expects( :resolve_target ).with( path ).once.then.returns( path )
+        @installer.target.should == path
+        @installer.target.should == path
+      end
+    end
+
+    # populate
+    describe "when populate called" do
+      it "should call all steps of populate process" do
+        @installer = Sandbox::Installer.new
+        @installer.stubs( :tell )
+        @installer.stubs( :target ).returns( '/tmp/sandbox' )
+        @installer.expects( :create_directories )
+        @installer.expects( :install_scripts )
+        @installer.expects( :install_gemrc )
+        @installer.expects( :install_gems )
+        @installer.populate
+      end
+    end
+
+    # create_directories
+    describe "when create_directories called" do
+      before( :each ) do
+        @path = '/some/new/target'
+        @installer = Sandbox::Installer.new
+        @installer.stubs( :target ).returns( @path )
+      end
+      it "should create sandbox directory structure" do
+        FileUtils.expects( :mkdir_p ).with( @path + '/rubygems/bin' )
+        FileUtils.stubs( :ln_s )
+        @installer.create_directories
+      end
+      
+      it "should symlink gem bin directory" do
+        FileUtils.stubs( :mkdir_p )
+        FileUtils.expects( :ln_s ).with( @path + '/rubygems/bin', @path + '/bin' )
+        @installer.create_directories
+      end
+    end
+
+    # install_scripts
+    describe "when install_scripts called" do
+      before( :each ) do
+        @path = '/some/new/target'
+        @installer = Sandbox::Installer.new
+        @installer.stubs( :target ).returns( @path )
+      end
+      
+      it "should read template file" do
+        File.expects( :read ).with( regexp_matches( /templates\/activate\.erb/ ) ).returns( '<%= target %>' )
+        File.stubs( :open )
+        @installer.install_scripts
+      end
+      
+      it "should write out activate script to SANDBOX/bin/activate" do
+        file = StringIO.new
+        File.stubs( :read ).returns( '<%= target %>' )
+        File.expects( :open ).with( @path + '/bin/activate', 'w' ).yields( file )
+        @installer.install_scripts
+        file.string.should == @path
+      end
+    end
+    
+    # install_gemrc
+    describe "when install_gemrc called" do
+      before( :each ) do
+        @path = '/some/new/target'
+        @installer = Sandbox::Installer.new
+        @installer.stubs( :target ).returns( @path )
+      end
+      
+      it "should read template file" do
+        File.expects( :read ).with( regexp_matches( /templates\/gemrc\.erb/ ) ).returns( '' )
+        File.stubs( :open )
+        @installer.install_gemrc
+      end
+      
+      it "should write out gemrc to SANDBOX/.gemrc" do
+        file = StringIO.new
+        File.stubs( :read ).returns( 'gemrc' )
+        File.expects( :open ).with( @path + '/.gemrc', 'w' ).yields( file )
+        @installer.install_gemrc
+        file.string.should == 'gemrc'
+      end
+    end
+
+    # install_gems
+    describe "when install_gems called" do
+      before( :each ) do
+        @installer = Sandbox::Installer.new( :gems => [ 'mygem' ] )
+        @installer.stubs( :setup_sandbox_env )
+        @installer.stubs( :restore_sandbox_env )
+        @installer.stubs( :tell )
+        @installer.stubs( :tell_unless_really_quiet )
+      end
+      
+      # it "should skip install when network is not available" do
+      #   Ping.expects( :pingecho ).with( 'gems.rubyforge.org' ).returns( false )
+      #   @installer.install_gems.should be_false
+      # end
+      
+      it "should install a good gem" do
+        @installer.expects( :shell_out ).with( 'gem install mygem' ).returns( [ true, 'blah' ] )
+        @installer.install_gems
+      end
+      
+      it "should gracefully handle a bad gem" do
+        @installer.expects( :shell_out ).with( 'gem install mygem' ).returns( [ false, 'blah' ] )
+        @installer.expects( :tell_unless_really_quiet ).with( regexp_matches( /failed/ ) )
+        @installer.install_gems
+      end
+    end
+
+    # resolve_target( path )
+    describe "when resolve_target called" do
+      before( :each ) do
+        @path = '/absolute/path/to/parent'
+        @installer = Sandbox::Installer.new
+        @installer.stubs( :fix_path ).returns( @path )
+      end
+      
+      it "should raise error when it path exists" do
+        File.expects( :exists? ).with( @path ).returns( true )
+        lambda { @installer.resolve_target( @path ) }.should raise_error( Sandbox::Error )
+      end
+      
+      it "should return path when parent directory passes check_path!" do
+        File.expects( :exists? ).with( @path ).returns( false )
+        @installer.expects( :check_path! ).with( '/absolute/path/to' ).returns( true )
+        @installer.resolve_target( @path ).should == @path
+      end
+      
+      it "should return path when any parent directory passes check_path!" do
+        File.expects( :exists? ).with( @path ).returns( false )
+        @installer.expects( :check_path! ).with( '/absolute/path/to' ).returns( false )
+        @installer.expects( :check_path! ).with( '/absolute/path' ).returns( false )
+        @installer.expects( :check_path! ).with( '/absolute' ).returns( true )
+        @installer.resolve_target( @path ).should == @path
+      end
+      
+      it "should have emergency safeguard for dirname on root" do
+        @installer.stubs( :fix_path ).returns( '/absolute' )
+        @installer.expects( :check_path! ).with( '/' ).returns( false )
+        lambda { @installer.resolve_target( '/absolute' ) }.should raise_error( RuntimeError )
+      end
+    end
+
+    # check_path!( path )
+    describe "when check_path! called" do
+      before( :each ) do
+        @path = '/absolute/path/to/parent'
+        @installer = Sandbox::Installer.new
+      end
+      
+      it "should raise error when it is not writable" do
+        File.expects( :directory? ).with( @path ).returns( true )
+        File.expects( :writable? ).with( @path ).returns( false )
+        lambda { @installer.check_path!( @path ) }.should raise_error( Sandbox::Error )
+      end
+      
+      it "should raise error when it is not a directory" do
+        File.expects( :directory? ).with( @path ).returns( false )
+        File.expects( :exists? ).with( @path ).returns( true )
+        lambda { @installer.check_path!( @path ) }.should raise_error( Sandbox::Error )
+      end
+      
+      it "should return false when it doesn't exist" do
+        File.expects( :directory? ).with( @path ).returns( false )
+        File.expects( :exists? ).with( @path ).returns( false )
+        @installer.check_path!( @path ).should be_false
+      end
+      
+      it "should return true when it can be created" do
+        File.expects( :directory? ).with( @path ).returns( true )
+        File.expects( :writable? ).with( @path ).returns( true )
+        @installer.check_path!( @path ).should == true
+      end
+    end
+
+    # fix_path( path )
+    describe "when fix_path called" do
+      it "should not change absolute path" do
+        path = '/absolute/path/to/target'
+        @installer = Sandbox::Installer.new
+        @installer.fix_path( path ).should == path
+      end
+      
+      it "should make relative into absolute path" do
+        abs_path = '/absolute/working/directory'
+        path = 'relative/path/to/target'
+        FileUtils.expects( :pwd ).returns( abs_path )
+        @installer = Sandbox::Installer.new
+        @installer.fix_path( path ).should == abs_path + '/' + path
+      end
+    end
+    
+    # shell_out( cmd )
+    describe "when shell_out called" do
+      it "should record true when successful" do
+        @installer = Sandbox::Installer.new
+        result = @installer.shell_out( 'true' )
+        result.first.should be_true
+      end
+      
+      it "should record false when unsuccessful" do
+        @installer = Sandbox::Installer.new
+        result = @installer.shell_out( 'false' )
+        result.first.should_not be_true
+      end
+      
+      it "should record std output" do
+        @installer = Sandbox::Installer.new
+        result = @installer.shell_out( 'ls -d /' )
+        result.last.chomp.should == '/'
+      end
+      
+      it "should ignore std error" do
+        @installer = Sandbox::Installer.new
+        result = @installer.shell_out( 'ls -d / 1>/dev/null' )
+        result.last.chomp.should == ''
+      end
+    end
+    
+    describe "setup and restore sandbox env called" do
+      it "should set and restore the environment" do
+        orig_home = ENV[ 'HOME' ]
+        orig_gem_home = ENV[ 'GEM_HOME' ]
+        orig_gem_path = ENV[ 'GEM_PATH' ]
+        @installer = Sandbox::Installer.new
+        @installer.stubs( :target ).returns( 'dummypath' )
+        
+        @installer.setup_sandbox_env
+        ENV[ 'HOME' ].should == 'dummypath'
+        ENV[ 'GEM_HOME' ].should == 'dummypath/rubygems'
+        ENV[ 'GEM_PATH' ].should == 'dummypath/rubygems'
+        @installer.restore_sandbox_env
+        ENV[ 'HOME' ].should == orig_home
+        ENV[ 'GEM_HOME' ].should == orig_gem_home
+        ENV[ 'GEM_PATH' ].should == orig_gem_path
+      end
+    end
+  end
+end
+
+describe Sandbox::Installer, "(using tmpdir)" do
+  def tmppath() File.join( Dir.tmpdir, "sandbox_testing" ) end
+  def rmtmppath() FileUtils.rm_rf( tmppath ) end
+  def mktmppath() FileUtils.mkdir_p( tmppath ) end
+
+  def in_dir( dir = tmppath )
+    old_pwd = Dir.pwd
+    begin
+      Dir.chdir( dir )
+      yield
+    ensure
+      Dir.chdir( old_pwd )
+    end
+  end
+  
+  before( :each ) do
+    mktmppath
+  end
+  
+  after( :each ) do
+    rmtmppath
+  end
+  
+  it "should create target directory structure" do
+    target = tmppath + '/target'
+    @installer = Sandbox::Installer.new( :target => target )
+    @installer.create_directories
+    File.directory?( target + '/rubygems/bin' ).should be_true
+    File.symlink?( target + '/bin' ).should be_true
+  end
+end
+
+
+