cuken 0.1.4 → 0.1.7

data/spec/api/knife_spec.rb

@@ -0,0 +1,94 @@
+require Pathname(__FILE__).ascend { |d| h=d+'spec_helper.rb'; break h if h.file? }
+
+module ::Cuken::Api::Chef
+
+  describe Knife do
+    before :all do
+      ::Chef::Config[:node_name]  = "webmonkey.example.com"
+      @knife = ::Chef::Knife::ClientCreate.new
+    @knife.config = {
+      :file => nil
+    }
+      @client = ::Chef::ApiClient.new
+    end
+    describe "#create_client(data)" do
+      it "should create a new named admin Client" do
+        data = {:name => 'Im_new_here',
+                :config_file => '/some/knife.rb',
+                :admin => true,
+                :file => '/some/sekret.pem',
+                :no_editor => true}
+         any_instance_of(::Chef::ApiClient) do |u|
+           stub(u).name.with(data[:name]).times(1)
+           stub(u).name.with("").times(1) # some json creation routine
+           stub(u).admin.with(data[:admin]).times(1)
+           stub(u).admin.with(false).times(1) # some json creation routine
+           stub(u).save{ { 'private_key' => 'sekret' } }
+         end
+         stub(Chef::Config).from_file.with(is_a(String))
+        FakeFS do
+          chef.knife.create_client(data)
+          File.read(data[:file]).should == 'sekret'
+        end
+      end
+      it "should create a new named non-admin Client" do
+        data = {:name => 'Im_new_here',
+                :config_file => '/some/knife.rb',
+                :admin => false,
+                :file => '/some/sekret2.pem',
+                :no_editor => true}
+         any_instance_of(::Chef::ApiClient) do |u|
+           stub(u).name.with(data[:name]).times(1)
+           stub(u).name.with("").times(1) # some json creation routine
+           stub(u).admin.with(nil).times(1)
+           stub(u).admin.with(false).times(1) # some json creation routine
+           stub(u).save{ { 'private_key' => 'sekret2' } }
+         end
+        stub(Chef::Config).from_file.with(is_a(String))
+        FakeFS do
+          chef.knife.create_client(data)
+          File.read(data[:file]).should == 'sekret2'
+        end
+      end
+    end
+    describe "#show_client(data)" do
+      it "should show a named Client" do
+        data = {:name => 'Im_new_here',
+                :config_file => '/some/knife.rb',
+                :file => '/some/sekret.pem',
+                :no_editor => true}
+        stub(Chef::Config).from_file.with(is_a(String))
+        stub(Chef::ApiClient).load.with(data[:name]){['somthing: displayed']}
+        FakeFS do
+          chef.knife.show_client(data).should be_nil
+
+        end
+      end
+    end
+#    describe "#check_client(data)" do
+#      it "should check a named Client" do
+#        data = {:name => 'Im_new_here',
+#                :file => '/some/sekret.pem',
+#                :no_editor => true}
+#        stub(Chef::Config).from_file.with(is_a(String))
+#        stub(Chef::ApiClient).load.with(data[:name]){['somthing: displayed']}
+#        FakeFS do
+#          chef.knife.check_client(data).should match /somthing: displayed/
+#         end
+#      end
+#    end
+    describe "#delete_client(data)" do
+      it "should delete a named Client" do
+        data = {:name => 'Im_new_here',
+                :config_file => '/some/knife.rb',
+                :file => '/some/sekret.pem',
+                :no_editor => true}
+        stub(Chef::Config).from_file.with(is_a(String))
+        stub(Chef::ApiClient).load.with(data[:name]){stub!.destroy{true}}
+        FakeFS do
+          chef.knife.delete_client(data).should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/api/rvm_spec.rb

@@ -0,0 +1,274 @@
+require Pathname(__FILE__).ascend { |d| h=d+'spec_helper.rb'; break h if h.file? }
+
+#Reference:
+# http://www.metaskills.net/2010/07/30/the-rvm-ruby-api/
+
+module ::Cuken::Api
+  describe Rvm do
+    before(:all) do
+      include ::Cuken::Api::Rvm
+#      ::FakeFS.activate!
+#      ::FakeFS::FileSystem.clear
+      @rvmrc_root = setup_rvmrc_gems_files(1)
+      @rvmrc_file = Dir.glob(@rvmrc_root + '/**' + '/.rvmrc')[-1]
+    end
+    before(:each) do
+      puts self.class
+      @rvmrc_processor= ::Cuken::Api::Rvm::RvmrcProcessor.new(@rvmrc_file)
+    end
+    after(:all) do
+#      ::FakeFS.deactivate!
+    end
+#    context ".b3_setup" do
+#      it "should set the path to BigBlueButton's sources root" do
+#         ::Cuken::Api::Rvm.rvm_setup.directory?.should be_true
+#      end
+#      it "should raise an error if the path to BigBlueButton's sources root does not exist" do
+#        FakeFS { lambda{ ::B3::Bdd::Helpers.b3_setup}.should raise_error(RuntimeError, /Could not find BigBlueButton's sources root./) }
+#      end
+#    end
+
+    describe ".rvm_current_name" do
+      it "should return the full rubie and gemset name" do
+        ::Cuken::Api::Rvm.rvm_current_name.should =~ /ruby(.*)@(.*)/
+      end
+    end
+
+    describe ".rvm_path" do
+      it "should return a Pathname of the rvm_path environment variable" do
+        ::Cuken::Api::Rvm.rvm_path.should be_kind_of Pathname
+      end
+      it "should return the path to RVM's install root if it exists" do
+         ::Cuken::Api::Rvm.rvm_path.directory?.should be_true
+      end
+      it "should raise an error if RVM's install root does not exist" do
+        FakeFS { lambda{ ::Cuken::Api::Rvm.rvm_path}.should raise_error(RuntimeError, /Could not find RVM's .rvm folder/) }
+      end
+    end
+    describe ".rvm_local_install?" do
+      it "should indicate RVM is installed locally" do
+        ::Cuken::Api::Rvm.rvm_local_install?.should be_true
+      end
+    end
+
+    context ".rvm_loaded? with RVM" do
+      it "should return true when RVM is installed locally" do
+        ::Cuken::Api::Rvm.rvm_loaded?.should be_true
+      end
+    end
+
+    context ".rvm_loaded? without RVM" do
+      it "should return false when RVM is not installed locally" do
+        FakeFS do
+          ::Cuken::Api::Rvm.rvm_loaded?.should be_false
+        end
+      end
+    end
+
+    context ".rvm_gemset_paths with root path argument" do
+      it "should return default paths requiring RVM gemsets be loaded" do
+        FakeFS do
+          root_path = setup_rvmrc_gems_files(8)
+          ::Cuken::Api::Rvm.rvm_gemset_paths(root_path).should have(9).items
+        end
+      end
+    end
+
+    context ".rvmrc_rubies_gemsets without root path argument" do
+      it "should return a hash whose keys are rubies (in the .rvmrc files)" do
+        FakeFS do
+          root_path = setup_rvmrc_gems_files(1)
+          ::Cuken::Api::Rvm.rvmrc_rubies_gemsets(root_path).should be_kind_of(Hash)
+          ::Cuken::Api::Rvm.rvmrc_rubies_gemsets(root_path).keys.each {|k| k.should match /ruby/ }
+        end
+      end
+      it "should return a hash whose values are array of gemsets (in the .rvmrc files)" do
+        ::Cuken::Api::Rvm.rvmrc_rubies_gemsets.each do |k, v|
+          k.should match /ruby/
+          v.should be_kind_of(Array)
+          v.each{|elem| elem.should be_kind_of(Hash) }
+        end
+      end
+      it "should return RVM gemsets names that exist in the .rvmrc files" do
+        FakeFS do
+          root_path = setup_rvmrc_gems_files(8)
+          res = ::Cuken::Api::Rvm.rvmrc_rubies_gemsets(root_path)
+          res.should have(1).item
+          res.first.last.should have(9).items
+        end
+      end
+    end
+
+    context ".rvmrc_rubies without root path argument" do
+      it "should return RVM Ruby names that exist in the .rvmrc files" do
+          ::Cuken::Api::Rvm.rvm_install_rubies = {'ruby-1.9.2-p136'   => {:alias => 'cuken192'}}
+          res = ::Cuken::Api::Rvm.rvmrc_rubies
+          res.should have(1).item
+          res.first.should have(2).items
+      end
+      it "should contain an alias with prefix cuken-" do
+        ::Cuken::Api::Rvm.rvmrc_rubies.each do |k, v|
+          v[:alias].should match /\Acuken-/
+        end
+      end
+    end
+
+    context ".rvm_rubies_setup without root path argument" do
+      it "should raise an error if RVM's install root does not exist" do
+        FakeFS { lambda{ ::Cuken::Api::Rvm.rvm_rubies_setup}.should raise_error(RuntimeError, /RVM library not loaded./) }
+      end
+      it "should not install existing RVM rubies that exists in the .rvmrc files" do
+        rvm_now=(`rvm current`)[/(.*)@/,1]
+        mock(::RVM).install(rvm_now,{}).times(0){true}
+        mock(::RVM).alias_create.with(is_a(String),/@vagrant/).times(1) { true }
+        ::Cuken::Api::Rvm.rvm_rubies_setup.should have(1).item
+      end
+    end
+
+    describe ".rvm_install_gemspecs" do
+      it "should return an array of 2-element arrays with gem name and version" do
+        ::Cuken::Api::Rvm.rvm_install_gemspecs << ['gem_a', '1.0.0']
+        ::Cuken::Api::Rvm.rvm_install_gemspecs << ['gem_b', '2.0.0']
+        ::Cuken::Api::Rvm.rvm_install_gemspecs.should == [["bundler", "1.0.10"], ["gem_a", "1.0.0"], ["gem_b", "2.0.0"]]
+      end
+    end
+
+    describe ".rvm_create_gemsets" do
+      it "should return an array of gemsets names" do
+        ::Cuken::Api::Rvm.rvm_create_gemsets << 'gemset_a'
+        ::Cuken::Api::Rvm.rvm_create_gemsets << 'gemset_b'
+        ::Cuken::Api::Rvm.rvm_create_gemsets.should == ["gemset_a", "gemset_b"]
+      end
+    end
+
+    context ".rvmrc_gems_install" do
+      it "should require a directory path argument" do
+        lambda{::Cuken::Api::Rvm.rvmrc_gems_install}.should  raise_error(ArgumentError, /wrong number of arguments \(0 for 1\)/)
+      end
+    end
+
+    context ".rvmrc_gems_install when gem is not installed" do
+      it "should install gems added to rvm_install_gemspecs" do
+        FakeFS do
+          root_path = setup_rvmrc_gems_files(8)
+          ::Cuken::Api::Rvm.rvm_install_gemspecs << ['gem_a', '1.0.0']
+          ::Cuken::Api::Rvm.rvm_install_gemspecs << ['gem_b', '2.0.0']
+          mock(::RVM).use.with("ruby-1.9.2-p136").times(2){true}
+          #mock(::RVM).gemset.stub!.create.with(is_a(String)).times(9){true}
+          mock(::RVM).gemset.times(27).stub!.use!.with(is_a(String)).times(27){true}
+          # mock(::RVM).gemset_import.with(is_a(String)).times(8) { true }
+          #mock(::RVM).perform_set_operation.with(is_a(Symbol),is_a(String),is_a(String),is_a(String),is_a(String)).times(4){ stub!.stdout{ "some progress messages" } }
+          #mock(::RVM).perform_set_operation.with(is_a(Symbol),is_a(String),is_a(String),is_a(String),is_a(String)).times(4){ stub!.stdout{ "some progress messages" } }
+          mock(::RVM).ruby_eval.with(is_a(String)).times(27){ stub!.stdout{'false'}}
+          mock(::RVM).run.with(is_a(String)).times(27){ stub!.stdout{'false'}}
+          ::Cuken::Api::Rvm.rvmrc_gems_install(root_path).should be_true
+        end
+      end
+    end
+
+    context ".rvmrc_gems_install when gem is installed" do
+      it "should not install gems added to rvm_install_gemspecs" do
+        FakeFS do
+          root_path = setup_rvmrc_gems_files(8)
+          ::Cuken::Api::Rvm.rvm_install_gemspecs << ['gem_a', '1.0.0']
+          ::Cuken::Api::Rvm.rvm_install_gemspecs << ['gem_b', '2.0.0']
+          stub(::RVM).use.verbose.with(is_a(String))
+          #stub(::RVM).gemset.times(27).stub!.create.verbose.with(is_a(Array)).times(27){true}
+          stub(::RVM).gemset.times(27).stub!.use.verbose.with(is_a(String)).times(27){true}
+          # mock(::RVM).use.with(is_a(String)).times(1){true}
+          # mock(::RVM).gemset_import.with(is_a(String)).times(8) { true }
+          mock(::RVM).perform_set_operation.with(is_a(Symbol),is_a(String),is_a(String),is_a(String),is_a(String)).times(0){ stub!.stdout{ "some progress messages" } }
+          mock(::RVM).ruby_eval.with(is_a(String)).times(27){ stub!.stdout{'true'}}
+          ::Cuken::Api::Rvm.rvmrc_gems_install(root_path).should be_true
+        end
+      end
+    end
+
+#    context ".rvmrc_gemsets_install when gemset is not installed" do
+#      it "should install gemsets found in .rvmrc files" do
+#        FakeFS do
+#          root_path = setup_rvmrc_gems_files(8)
+#          mock(::RVM).use.with(is_a(String)).times(1){true}
+#          mock(::RVM).gemset_import.with(is_a(String)).times(8) { true }
+#          #mock(::RVM).perform_set_operation.with(is_a(Symbol),is_a(String),is_a(String),is_a(String),is_a(String)).times(3){ stub!.stdout{ "some progress messages" } }
+#          #mock(::RVM).ruby_eval.with(is_a(String)).times(3){ stub!.stdout{'false'}}
+#          ::Cuken::Api::Rvm.rvmrc_gems_install(root_path).should be_true
+#        end
+#      end
+#    end
+#
+#    context ".rvmrc_gemsets_install" do
+#      it "should require a directory path argument" do
+#        lambda{::Cuken::Api::Rvm.rvmrc_gemsets_install}.should  raise_error(ArgumentError, /wrong number of arguments \(0 for 1\)/)
+#      end
+#    end
+
+    describe ".rvm_steup" do
+      it "should require RVM and the libraries this API requires"
+    end
+
+    describe "_rvm_current_rubie_name" do
+      it "should return the rubie name without any gemset"
+    end
+    describe "#rvm_gem_available?(spec)" do
+      it "should expect gem name and version as an array"
+      it "should return true if the gem can be required"
+    end
+  end
+end
+
+#module B3
+#  module Bdd
+#    module Helpers
+#
+#    end
+#  end
+#end
+#describe ::B3::Bdd::Helpers do
+#  context ".b3_setup" do
+#    it "should set the path to BigBlueButton's sources root" do
+#       ::B3::Bdd::Helpers.b3_setup.directory?.should be_true
+#    end
+#    it "should raise an error if the path to BigBlueButton's sources root does not exist" do
+#      FakeFS { lambda{ ::B3::Bdd::Helpers.b3_setup}.should raise_error(RuntimeError, /Could not find BigBlueButton's sources root./) }
+#    end
+#  end
+#
+#  context ".b3_bdd_feature_sets(hsh)" do
+#    it "should return the subset of hash having feature sets" do
+#      hsh = ::B3::Bdd::Helpers.b3_bdd_feature_sets
+#      hsh.first.last.should have(3).items
+#      hsh.should be_kind_of(Hash)
+#      hsh.each do |k, v|
+#              k.should match /ruby/
+#              v.each{|elem| elem.key? :feature_set_name }
+#      end
+#    end
+#  end
+#
+#  context ".b3_bdd_features_parser" do
+#    it "should accept an empty hash and return default set_profile" do
+#      hsh = ::B3::Bdd::Helpers.b3_bdd_features_parser
+#      hsh.keys.should == [:set_profile]
+#      hsh[:set_profile].keys.should == ["bbb_bdd_app", "bbb_bdd_sys_os", "bbb_bdd_meta_bdd"]
+#      hsh.each do |k, v|
+#              k.should match /ruby/
+#              v.each do |elem|
+#                elem.key?(:feature_set_name).should be_true
+#                elem.key?(:profiles).should be_true
+#                elem.value(:profiles).should == ["default"]
+#              end
+#      end
+#    end
+#  end
+#
+#  context ".b3_bdd_run :feature" do
+#    it "should run all feature sets with default Cucumber profile" do
+#      mock(::RVM).use.with(is_a(String)).times(8){true}
+#      mock(::RVM).use_from_path!.with(is_a(String)).times(3){true}
+#      mock(::Open4).popen4.with(is_a(String)).times(3) { true }
+#      ::B3::Bdd::Helpers.b3_bdd_run(:feature,{}).should be_true
+#    end
+#  end
+#
+#end

data/spec/api/rvmrc_processor_spec.rb

@@ -0,0 +1,288 @@
+require Pathname(__FILE__).ascend { |d| h=d+'spec_helper.rb'; break h if h.file? }
+
+
+module ::Cuken::Api::Rvm
+  describe RvmrcProcessor do
+    before(:all) do
+      ::FakeFS.activate!
+      ::FakeFS::FileSystem.clear
+      @rvmrc_root = setup_rvmrc_gems_files(1)
+      @rvmrc_file = Dir.glob(@rvmrc_root + '/**' + '/.rvmrc')[-1]
+    end
+    before(:each) do
+      @rvmrc_processor= ::Cuken::Api::Rvm::RvmrcProcessor.new(@rvmrc_file)
+    end
+    after(:all) do
+      ::FakeFS.deactivate!
+    end
+    describe "#rvmrc_read"  do
+      context "given the path to a .rvmrc file"  do
+        it "should return the file contents" do
+          rvmrc_contents = @rvmrc_processor.rvmrc_read(@rvmrc_file)
+          rvmrc_contents.should be_true
+        end
+      end
+      context "given the path to folder with a .rvmrc file"  do
+        it "should read the file contents and return true on success" do
+          rvmrc_contents = @rvmrc_processor.rvmrc_read(File.dirname(@rvmrc_file))
+          rvmrc_contents.should be_true
+        end
+        describe "#rvmrc" do
+          it "should return the contents of the .rvmrc file" do
+            @rvmrc_processor.rvmrc_read(@rvmrc_file)
+            @rvmrc_processor.rvmrc.size.should == 544
+          end
+        end
+      end
+    end
+
+    context "having read the .rvmrc file" do
+      before(:all) do
+        @rvmrc_processor = ::Cuken::Api::Rvm::RvmrcProcessor.new(@rvmrc_file)
+      end
+      describe "#rvmrc_ruby_name" do
+        it "should return the rubie name from the .rvmrc file" do
+          @rvmrc_processor.rvmrc_ruby_name.should == "ruby-1.9.2-p136"
+        end
+      end
+      describe "#rvmrc_gemset_name" do
+        it "should return the gemset name from the .rvmrc file" do
+          @rvmrc_processor.rvmrc_gemset_name.should == "1"
+        end
+      end
+      describe "#find_rvmrc_files" do
+        it "should return an array of .rvmrc file paths found beneath a root folder" do
+          @rvmrc_processor.find_rvmrc_files(@rvmrc_root).should == ["/path/to/dir/.rvmrc", "/path/to/dir/1/.rvmrc"]
+        end
+      end
+      describe "#find_rvmrc_paths" do
+        context "when given a folder path" do
+          it "should return an array of paths to .rvmrc files found beneath a root folder" do
+            @rvmrc_processor.find_rvmrc_paths(@rvmrc_root).should == ["/path/to/dir", "/path/to/dir/1"]
+          end
+        end
+        context "when given a file path" do
+          it "should return an array of paths to .rvmrc files found beneath a root folder" do
+            @rvmrc_processor.find_rvmrc_paths(@rvmrc_root+'/.rvmrc').should == ["/path/to/dir", "/path/to/dir/1"]
+          end
+        end
+      end
+      describe "#find_gems_files" do
+        it "should return an array of *.gems file paths found beneath a root folder" do
+          @rvmrc_processor.find_gems_files(@rvmrc_root).should == ["/path/to/dir/1/1.gems", "/path/to/dir/dir.gems"]
+        end
+      end
+      describe "#all_rubies_gemsets" do
+        context "when passed a folder path" do
+         it "should return a hash whose keys are rubies (in the .rvmrc files)" do
+           @rvmrc_processor.all_rubies_gemsets(@rvmrc_root).should be_kind_of(Hash)
+           @rvmrc_processor.all_rubies_gemsets(@rvmrc_root).keys.each {|k| k.should match /ruby/ }
+         end
+         it "should return a hash whose values are array of gemsets (in the .rvmrc files)" do
+           @rvmrc_processor.all_rubies_gemsets(@rvmrc_root).each do |k, v|
+             k.should match /ruby/
+             v.should be_kind_of(Array)
+             v.each do |elem|
+               elem.keys.should == [:ruby_alias, :gemset_alias, :gemset_name,:gemset_path]
+             end
+           end
+         end
+         it "should return RVM gemsets names that exist in the .rvmrc files" do
+           root_path = setup_rvmrc_gems_files(8)
+           res = @rvmrc_processor.all_rubies_gemsets(root_path)
+           res.should have(1).item
+           res.first.last.should have(9).items
+           res.first.last[0].keys.should == [:ruby_alias, :gemset_alias, :gemset_name, :gemset_path]
+         end
+        end
+        context "when not passed a folder path it uses the path passed to new and" do
+         it "should return a hash whose keys are rubies (in the .rvmrc files)" do
+           @rvmrc_processor.all_rubies_gemsets.should be_kind_of(Hash)
+           @rvmrc_processor.all_rubies_gemsets.keys.each {|k| k.should match /ruby/ }
+         end
+         it "should return a hash whose values are array of gemsets (in the .rvmrc files)" do
+           @rvmrc_processor.all_rubies_gemsets.each do |k, v|
+             k.should match /ruby/
+             v.should be_kind_of(Array)
+             v.each do |elem|
+               elem.keys.should == [:ruby_alias, :gemset_alias, :gemset_name,:gemset_path]
+             end
+           end
+         end
+         it "should return RVM gemsets names that exist in the .rvmrc files" do
+           res = @rvmrc_processor.all_rubies_gemsets
+           res.should have(1).item
+           res.first.last.should have(8).items
+           res.first.last[0].keys.should == [:ruby_alias, :gemset_alias, :gemset_name, :gemset_path]
+         end
+        end
+      end
+      describe "#all_gemsets" do
+        context "when passed a folder path" do
+          it "should return an Hash" do
+            @rvmrc_processor.all_gemsets(@rvmrc_root).should be_kind_of Hash
+          end
+          it "should use as keys the rubies found in .rvmrc files beneath a root folder" do
+            @rvmrc_processor.all_gemsets(@rvmrc_root).keys.should == ["ruby-1.9.2-p136"]
+          end
+          it "should return the alias and gemsets per ruby found in .rvmrc files beneath a root folder" do
+            @rvmrc_processor.all_gemsets(@rvmrc_root)["ruby-1.9.2-p136"].keys.should == [:ruby_alias, :gemsets]
+          end
+        end
+        context "when not passed a folder path" do
+          it "should return an Hash" do
+            @rvmrc_processor.all_gemsets.should be_kind_of Hash
+          end
+          it "should use as keys the rubies found in .rvmrc files beneath a root folder" do
+            @rvmrc_processor.all_gemsets.keys.should == ["ruby-1.9.2-p136"]
+          end
+          it "should return the alias and gemsets per ruby found in .rvmrc files beneath a root folder" do
+            @rvmrc_processor.all_gemsets["ruby-1.9.2-p136"].keys.should == [:ruby_alias, :gemsets]
+          end
+        end
+      end
+      describe "#all_rubies" do
+        it "should return an Array" do
+          @rvmrc_processor.all_rubies(@rvmrc_root).should be_kind_of Array
+        end
+        it "should return the rubies found in .rvmrc files beneath a root folder" do
+          @rvmrc_processor.all_rubies(@rvmrc_root).should == ["ruby-1.9.2-p136"]
+        end
+      end
+      describe "#each_ruby" do
+        it "should use each of the installed rubies" do
+          @rvmrc_processor.all_rubies(@rvmrc_root).each do |rubie|
+            mock(::RVM).use.with(rubie).times(1){true}.should be_true
+          end
+          @rvmrc_processor.each_ruby do |rubie|
+            true
+          end
+        end
+        it "should yield a block in the environment of each in the installed rubies" do
+          @rvmrc_processor.all_rubies(@rvmrc_root).each do |rubie|
+            mock(::RVM).use.with(rubie).times(1){true}.should be_true
+              return_value = @rvmrc_processor.each_ruby do |rubie|
+              raise unless match /ruby/
+              end
+            return_value.should==[rubie]
+          end
+        end
+         it "should return current Ruby string even if the given block raises in the environment of each in the installed rubies" do
+          @rvmrc_processor.all_rubies(@rvmrc_root).each do |rubie|
+            mock(::RVM).use.with(rubie).times(1){true}.should be_true
+            lambda {
+            return_value = @rvmrc_processor.each_ruby do |rubie|
+              raise if match /ruby/
+            end
+            return_value.should==[rubie]
+            }.should_not raise_error RuntimeError
+
+          end
+        end
+      end
+      describe "#create_gemsets" do
+        it "should create gemsets parsed from all .rvmrc files beneath a root folder" do
+          mock(::RVM).use.with(is_a(String)).times(1){true}
+          mock(::RVM).gemset.times(8).stub!.create.with(is_a(Array)).times(8){true}
+          @rvmrc_processor.create_gemsets
+        end
+      end
+
+      describe "gemspecs_to_install" do
+        it "should always install Bundler 1.0.10" do
+          @rvmrc_processor.gemspecs_to_install == [["bundler", "1.0.10"]]
+        end
+        it "should return an array of 2-element arrays with gem name and version" do
+          @rvmrc_processor.gemspecs_to_install << ['gem_a', '1.0.0']
+          @rvmrc_processor.gemspecs_to_install << ['gem_b', '2.0.0']
+          @rvmrc_processor.gemspecs_to_install == [["bundler", "1.0.10"], ["gem_a", "1.0.0"], ["gem_b", "2.0.0"]]
+        end
+      end
+
+      # Some subtle issue with this spec it fails whenthe whole file is run,
+      # but passes when run in isolation.
+      describe "#gems_install" do
+        it "should install gems from install_gemspecs_list into gemsets parsed from all .rvmrc files beneath a root folder" do
+          stub(@rvmrc_processor).install_gem.with(is_a(String),is_a(Array)).times(1){true}
+          @rvmrc_processor.gems_install
+        end
+      end
+      describe "#gem_install_options" do
+        it "should return the options string for Ruby's `gem install...` CLI" do
+          @rvmrc_processor.gem_install_options.should == "--no_ri --no_rdoc"
+        end
+      end
+      # Some subtle issue with this spec it fails whenthe whole file is run,
+      # but passes when run in isolation.
+      describe "#install_gem(rubie, spec)" do
+        context "when the gem is not installed" do
+          # Some subtle issue with this spec it fails whenthe whole file is run,
+          # but passes when run in isolation.
+          it "should install given gem into all ruby+gemsets parsed from .rvmrc files beneath a root folder" do
+            #mock(::RVM).use.with(is_a(String)).times(1){true}
+            stub(@rvmrc_processor).gem_available?.with(is_a(Array)).times(1){false}
+            mock(::RVM).gemset.times(1).stub!.use.with(is_a(String)).times(1){true}
+            mock(::RVM).run.with(is_a(String)).times(1){true}
+            @rvmrc_processor.install_gem("ruby-1.9.2-p136",["bundler", "1.0.10"])
+          end
+        end
+        context "when the gem is installed" do
+          it "should not install given gem into all ruby+gemsets parsed from .rvmrc files beneath a root folder" do
+            #mock(::RVM).use.with(is_a(String)).times(1){true}
+            stub(@rvmrc_processor).gem_available?.with(is_a(Array)).times(8){true}
+            mock(::RVM).gemset.times(0).stub!.use.with(is_a(String)).times(0){true}
+            mock(::RVM).run.with(is_a(String)).times(0){true}
+            @rvmrc_processor.install_gem("ruby-1.9.2-p136",["bundler", "1.0.10"])
+          end
+        end
+      end
+
+      describe "#current_ruby_info" do
+        it "should return the parsed .rvmrc info for the current ruby" do
+          @rvmrc_processor.current_ruby_info('ruby-1.9.2-p136').each do |hsh|
+             hsh.keys.should == [:ruby_alias, :gemset_alias, :gemset_name, :gemset_path]
+          end
+        end
+      end
+
+      describe "#setup_rubies " do
+        it "should raise an error if RVM's install root does not exist" do
+          lambda{ ::Cuken::Api::Rvm::RvmrcProcessor.new('/junk') }.should raise_error(Errno::ENOENT, /No such file or directory/)
+        end
+        context "when RVM ruby exists " do
+          it "should not install a Ruby listed in the .rvmrc files" do
+            rvm_now=(`rvm current`)[/(.*)@/,1]
+            mock(::RVM).list_strings.times(1).stub!.include?.with(is_a(String)).times(1){true}
+            mock(::RVM).alias_create.with(/cuken_/,is_a(String)).times(1) { true }
+            stub(@rvmrc_processor).install_rubie.with(is_a(String)).times(0){true}
+            @rvmrc_processor.setup_rubies.should have(1).item
+          end
+        end
+        context "when RVM ruby does not exist " do
+          it "should install a Ruby listed in the .rvmrc files" do
+            rvm_now=(`rvm current`)[/(.*)@/,1]
+            mock(::RVM).list_strings.times(1).stub!.include?.with(is_a(String)).times(1){false}
+            mock(::RVM).alias_create.with(/cuken_/,is_a(String)).times(1) { true }
+            stub(@rvmrc_processor).install_rubie.with(is_a(String)).times(1){true}
+            @rvmrc_processor.setup_rubies.should have(1).item
+          end
+        end
+      end
+      describe "#rvm_path" do
+        it "should return a Pathname of the rvm_path environment variable" do
+          ::FakeFS.deactivate!
+            @rvmrc_processor.rvm_path.should be_kind_of Pathname
+          ::FakeFS.activate!
+        end
+        it "should return the path to RVM's install root if it exists" do
+          ::FakeFS.deactivate!
+            @rvmrc_processor.rvm_path.directory?.should be_true
+          ::FakeFS.activate!
+        end
+        it "should raise an error if RVM's install root does not exist" do
+          FakeFS { lambda{ @rvmrc_processor.rvm_path}.should raise_error(RuntimeError, /Could not find RVM's .rvm folder/) }
+        end
+      end
+    end
+  end
+end