railsthemes 1.1.pre → 1.1.pre.2

data/spec/lib/railsthemes/installer_spec.rb

@@ -1,532 +1,176 @@
 require 'spec_helper'
 require 'railsthemes'
-require 'railsthemes/os'
+require 'json'
 
 describe Railsthemes::Installer do
-  def using_gems *gems
-    "GEM\nremote: https://rubygems.org/\nspecs:\n" +
-      gems.map{|gem| "    #{gem}"}.join("\n") +
-      "\nGEM\n  remote: https://rubygems.org/"
-  end
-
-  def using_gem_specs specs = {}
-    lines = []
-    specs.each { |name, version| lines << "    #{name} (#{version})"}
-    "GEM\nremote: https://rubygems.org/\nspecs:\n" +
-      lines.join("\n") +
-      "\nGEM\n  remote: https://rubygems.org/"
-  end
-
-  LOGFILE_NAME = 'railsthemes.log'
-
-  before :all do
-    File.delete(LOGFILE_NAME) if File.exists?(LOGFILE_NAME)
-  end
-
   before do
-    @logger = Logger.new(LOGFILE_NAME)
-    @logger.info "#{self.example.description}"
-    @installer = Railsthemes::Installer.new @logger
-    stub(@installer).ensure_in_rails_root
-    FakeWeb.register_uri(:get, "http://curl.haxx.se/ca/cacert.pem", :body => "CAs")
-    @tempdir = ''
-    if OS.windows?
-      @tempdir = File.join('C:', 'Users', 'Admin', 'AppData', 'Local', 'Temp')
-    else
-      @tempdir = 'tmp'
-    end
-    stub(@installer).generate_tempdir_name { @tempdir }
-    FileUtils.touch('Gemfile.lock')
+    setup_logger
+    @installer = Railsthemes::Installer.new
+    @tempdir = stub_tempdir
+
+    stub(Railsthemes::Ensurer).ensure_clean_install_possible
   end
 
   describe :install_from_file_system do
-    context 'when the filepath is a directory' do
-      it 'should copy the files from that directory into the Rails app' do
-        FileUtils.mkdir_p('filepath/base')
-        FileUtils.touch('filepath/base/a')
-        FileUtils.touch('filepath/base/b')
-        mock(@installer).post_copying_changes
-
-        @installer.install_from_file_system('filepath')
-        File.should exist('a')
-        File.should exist('b')
-      end
-
-      it 'should handle directories that have spaces' do
-        FileUtils.mkdir_p('file path/base')
-        FileUtils.touch('file path/base/a')
-        FileUtils.touch('file path/base/b')
-        mock(@installer).post_copying_changes
-
-        @installer.install_from_file_system('file path')
-        File.should exist('a')
-        File.should exist('b')
-      end
-
-      it 'should handle windows style paths' do
-        FileUtils.mkdir_p('fp1/fp2/base')
-        FileUtils.touch('fp1/fp2/base/a')
-        FileUtils.touch('fp1/fp2/base/b')
-        FileUtils.mkdir_p('fp1/fp2/gems')
-        mock(@installer).post_copying_changes
-
-        @installer.install_from_file_system('fp1\fp2')
-        File.should exist('a')
-        File.should exist('b')
-      end
-
-      it 'should not copy system files' do
-        FileUtils.mkdir_p('filepath/base')
-        FileUtils.touch('filepath/base/.DS_Store')
-        mock(@installer).post_copying_changes
-
-        @installer.install_from_file_system('filepath')
-        File.should_not exist('.DS_Store')
-      end
+    before do
+      FakeFS::FileSystem.clone('spec/fixtures')
+      stub(Railsthemes::Utils).get_primary_configuration { ['erb', 'css'] }
     end
 
-    describe 'override file behavior' do
+    describe 'installing theme' do
       before do
-        FileUtils.mkdir_p('filepath/gems')
-        FileUtils.mkdir_p('filepath/base/app/assets/stylesheets')
-        FileUtils.mkdir_p("app/assets/stylesheets")
-        @filename = 'app/assets/stylesheets/railsthemes_THEME_overrides.anything'
-        FileUtils.touch("filepath/base/#{@filename}")
-        mock(@installer).post_copying_changes
-        stub(@installer).popup_documentation
+        stub(@installer.email_installer).install_from_file_system(anything)
       end
 
-      it 'should not overwrite override files when they already exist' do
-        File.open(@filename, 'w') do |f|
-          f.write "existing override"
-        end
-
-        @installer.install_from_file_system('filepath')
-        File.should exist(@filename)
-        File.read(@filename).should =~ /existing override/
+      it 'should install the right theme version' do
+        mock(@installer.theme_installer).install_from_file_system('spec/fixtures/blank-assets/erb-css')
+        @installer.install_from_file_system 'spec/fixtures/blank-assets'
       end
 
-      it 'should create override files when they do not already exist' do
-        @installer.install_from_file_system('filepath')
-        File.should exist(@filename)
-        File.read(@filename).should == ''
+      it 'should install the right theme version if it is an archive in that directory' do
+        mock(@installer.theme_installer).install_from_file_system('spec/fixtures/blank-assets-archived/erb-css')
+        stub(@installer.email_installer).install_from_file_system(anything)
+        @installer.install_from_file_system 'spec/fixtures/blank-assets-archived'
       end
     end
 
-
-    context 'when the filepath is an archive file' do
-      it 'should extract the archive file to a temp directory if the archive exists' do
-        archive = 'tarfile.tar.gz'
-        FileUtils.touch archive
-        mock(@installer).install_from_archive archive
-        @installer.install_from_file_system archive
+    describe 'installing email theme' do
+      before do
+        stub(@installer.theme_installer).install_from_file_system(anything)
       end
 
-      it 'should print an error message and exit if the archive cannot be found' do
-        mock(Railsthemes::Safe).log_and_abort(/Cannot find/)
-        @installer.install_from_file_system 'tarfile.tar.gz'
+      it 'should install the email theme if present' do
+        mock(@installer.email_installer).install_from_file_system('spec/fixtures/blank-assets/email')
+        @installer.install_from_file_system 'spec/fixtures/blank-assets'
       end
-    end
 
-    context 'otherwise' do
-      it 'should print usage and report an error reading the file' do
-        mock(@installer).print_usage_and_abort(/either/)
-        @installer.install_from_file_system("does not exist")
+      it 'should install the archived email theme if present' do
+        mock(@installer.email_installer).install_from_file_system('spec/fixtures/blank-assets-archived/email')
+        @installer.install_from_file_system 'spec/fixtures/blank-assets-archived'
       end
     end
+  end
 
-    describe 'popping up the documentation on a successful install' do
+  # should probably move documentation stuff to another class
+  describe 'popping up the documentation' do
+    context 'when installing from the file system' do
       before do
-        # set up files for copying
-        FileUtils.mkdir_p('filepath/base')
-        FileUtils.touch('filepath/base/a')
-        FileUtils.touch('filepath/base/b')
-        FileUtils.mkdir_p('filepath/gems')
-        mock(@installer).post_copying_changes
+        FakeFS::FileSystem.clone('spec/fixtures')
+        stub(@installer.theme_installer).install_from_file_system(anything)
+        stub(@installer.email_installer).install_from_file_system(anything)
       end
 
       it 'should not pop it up when the user specified not to pop it up' do
         @installer.doc_popup = false
         dont_allow(@installer).popup_documentation
-        @installer.install_from_file_system 'filepath'
+        @installer.install_from_file_system 'spec/fixtures/blank-assets'
       end
 
       it 'should pop it up when the user did not specify to not pop it up' do
         mock(@installer).popup_documentation
-        @installer.install_from_file_system 'filepath'
+        @installer.install_from_file_system 'spec/fixtures/blank-assets'
       end
     end
   end
 
-  describe :install_gems_from do
-    it 'should install the gems that we specify that match' do
-      FakeFS::FileSystem.clone('spec/fixtures/blank-assets')
-      # we only know about formtastic and simple_form in the gems directory
-      @installer.install_gems_from("spec/fixtures/blank-assets", ['formtastic', 'kaminari'])
-      File.should exist('app/assets/stylesheets/formtastic.css.scss')
-      File.should_not exist('app/assets/stylesheets/kaminari.css.scss')
-      File.should_not exist('app/assets/stylesheets/simple_form.css.scss')
-    end
-  end
-
-  describe :install_from_archive do
-    # does not work on Windows, NotImplementedError in tar module
-    it 'should extract and then install from that extracted directory' do
-      filename = 'spec/fixtures/blank-assets.tar.gz'
-      FakeFS::FileSystem.clone(filename)
-      mock(@installer).install_from_file_system @tempdir
-      @installer.install_from_archive filename
-    end
-  end
-
-  describe :archive? do
-    it 'should be true for tar.gz file' do
-      @installer.archive?('test/a/b/c/d.tar.gz').should be_true
+  describe 'popup_documentation' do
+    it 'should not open if the style guide does not exist' do
+      dont_allow(Launchy).open(anything)
+      @installer.popup_documentation
     end
 
-    it 'should be false for other extensions' do
-      @installer.archive?('test/a/b/c.tar/d.zip').should be_false
+    it 'should open the style guide correctly if it exists' do
+      FileUtils.mkdir_p('doc')
+      filename = 'doc/Theme_Envy_Usage_And_Style_Guide.html'
+      FileUtils.touch(filename)
+      mock(Launchy).open(filename)
+      @installer.popup_documentation
     end
   end
 
-  describe 'end to end operation' do
-    def verify_end_to_end_operation
-      ['app/assets/images/image1.png',
-       'app/assets/images/bg/sprite.png',
-       'app/assets/javascripts/jquery.dataTables.js',
-       'app/assets/javascripts/scripts.js.erb',
-       'app/assets/stylesheets/style.css.erb',
-       'app/views/layouts/_interior_sidebar.html.erb',
-       'app/views/layouts/application.html.erb',
-       'app/views/layouts/homepage.html.erb'].each do |filename|
-         File.should exist(filename), "#{filename} was not present"
-      end
-      File.open('app/assets/stylesheets/style.css.erb').each do |line|
-        line.should match /style.css.erb/
-      end
+  describe '#download_from_hash' do
+    it 'should download and install main theme when theme specified' do
+      mock(Railsthemes::Utils).download(:url => 'theme_url', :save_to => "dir/erb-css.tar.gz")
+      @installer.download_from_hash({'theme' => 'theme_url'}, 'dir')
     end
 
-    before do
-      stub(@installer).post_copying_changes
-      FakeFS::FileSystem.clone('spec/fixtures')
-      # should add some gems to the gemfile here and test gem installation
-    end
-
-    it 'should extract correctly from directory' do
-      filename = 'spec/fixtures/blank-assets'
-      @installer.install_from_file_system filename
-      verify_end_to_end_operation
-    end
-
-    # does not work on Windows, NotImplementedError in tar module
-    it 'should extract correctly from archive' do
-      filename = 'spec/fixtures/blank-assets.tar.gz'
-      @installer.install_from_file_system filename
-      verify_end_to_end_operation
+    it 'should download and install email theme when email specified' do
+      mock(Railsthemes::Utils).download(:url => 'email_url', :save_to => "dir/email.tar.gz")
+      @installer.download_from_hash({'email' => 'email_url'}, 'dir')
     end
   end
 
-  describe :send_gemfile do
+  describe '#install_from_code' do
     before do
-      File.open('Gemfile.lock', 'w') do |file|
-        file.puts "GEM\n  remote: https://rubygems.org/"
-      end
+      mock(@installer).send_gemfile('code')
     end
 
-    it 'should hit the server with the Gemfile and return the results, arrayified' do
-      FakeFS.deactivate! # has an issue with generating tmpfiles otherwise
-      params = { :code => 'panozzaj@gmail.com:code', :gemfile_lock => File.new('Gemfile.lock', 'rb') }
-      FakeWeb.register_uri :post, 'https://railsthemes.com/gemfiles/parse',
-        :body => 'haml,scss', :parameters => params
-      @installer.send_gemfile('panozzaj@gmail.com:code')
+    it 'should download and install when the code is recognized' do
+      mock(@installer).get_download_hash('code') { :hash }
+      mock(@installer).download_from_hash(:hash, @tempdir)
+      mock(@installer).install_from_file_system(@tempdir)
+      @installer.install_from_code 'code'
     end
 
-    it 'should return a blank array when there are issues' do
-      FakeFS.deactivate! # has an issue with generating tmpfiles otherwise
-      FakeWeb.register_uri :post, 'https://railsthemes.com/gemfiles/parse',
-        :body => '', :parameters => :any, :status => ['401', 'Unauthorized']
-      @installer.send_gemfile('panozzaj@gmail.com:code')
+    it 'should print an error message when the code is not recognized' do
+      mock(@installer).get_download_hash('code') { nil }
+      dont_allow(@installer).download_from_hash(:hash, @tempdir)
+      dont_allow(@installer).install_from_file_system(@tempdir)
+      mock(Railsthemes::Safe).log_and_abort(/didn't recognize/)
+      @installer.install_from_code 'code'
     end
   end
 
-  describe :ask_to_install_unsupported do
-    it 'should abort if the user does not want to continue' do
-      mock(Railsthemes::Safe).yes?(/wish to install/) { false }
-      mock(Railsthemes::Safe).log_and_abort('Halting.')
-      @installer.ask_to_install_unsupported 'code'
-    end
-
-    it 'should continue if the user wants to continue' do
-      mock(Railsthemes::Safe).yes?(/wish to install/) { true }
-      mock(@installer).install_from_server('code')
-      @installer.ask_to_install_unsupported 'code'
-    end
-  end
-
-  describe :download_from_code do
-    it 'should abort if the VCS is not clean' do
-      mock(@installer).check_vcs_status { 'msg' }
-      mock(Railsthemes::Safe).log_and_abort('msg')
-      @installer.download_from_code 'thecode'
-    end
-
-    it 'should abort if the installer version is not up-to-date' do
-      mock(@installer).check_vcs_status
-      mock(@installer).check_installer_version { 'msg' }
-      mock(Railsthemes::Safe).log_and_abort('msg')
-      @installer.download_from_code 'thecode'
-    end
-
-    it 'should ask the user if they still want to install when a Gemfile.lock is not present' do
-      File.unlink('Gemfile.lock')
-      mock(@installer).check_vcs_status
-      mock(@installer).check_installer_version
-      mock(@installer).ask_to_install_unsupported 'thecode'
-      @installer.download_from_code 'thecode'
-    end
-
-    it 'should ask the user if they still want to install when the rails version is < 3.1' do
-      mock(@installer).check_vcs_status
-      mock(@installer).check_installer_version
-      mock(@installer).rails_version { Gem::Version.new('3.0.9') }
-      mock(@installer).ask_to_install_unsupported 'thecode'
-      @installer.download_from_code 'thecode'
-    end
-
-    it 'should install from the server otherwise' do
-      mock(@installer).check_vcs_status
-      mock(@installer).check_installer_version
-      mock(@installer).rails_version { Gem::Version.new('3.1.0') }
-      mock(@installer).install_from_server 'thecode'
-      @installer.download_from_code 'thecode'
-    end
-  end
-
-  def with_installer_version version, &block
-    old_version = Railsthemes::VERSION
-    Railsthemes.send(:remove_const, 'VERSION')
-    Railsthemes.const_set('VERSION', version)
-
-    block.call
-
-    Railsthemes.send(:remove_const, 'VERSION')
-    Railsthemes.const_set('VERSION', old_version)
-  end
-
-  describe '#check_installer_version' do
-    it 'should return message if the current installer version is < server recommendation' do
-      FakeWeb.register_uri :get, /\/installer\/version$/, :body => '1.0.4'
-      with_installer_version '1.0.3' do
-        result = @installer.check_installer_version
-        result.should_not be_nil
-        result.should match(/Your version is older than the recommended version/)
-        result.should match(/Your version: 1\.0\.3/)
-        result.should match(/Recommended version: 1\.0\.4/)
-      end
-    end
-
-    it 'should return nothing if the current installer version is = server recommendation' do
-      FakeWeb.register_uri :get, /\/installer\/version$/, :body => '1.0.4'
-      with_installer_version '1.0.4' do
-        result = @installer.check_installer_version
-        result.should be_nil
-      end
-    end
-
-    it 'should return nothing if the current installer version is > server recommendation' do
-      FakeWeb.register_uri :get, /\/installer\/version$/, :body => '1.0.4'
-      with_installer_version '1.0.5' do
-        result = @installer.check_installer_version
-        result.should be_nil
-      end
+  describe '#get_download_hash' do
+    it 'should download the file correctly when valid configuration' do
+      FakeWeb.register_uri :get,
+        /download\?code=panozzaj@gmail.com:code&config=haml,scss&v=2/,
+        :body => { 'theme' => 'auth_url' }.to_json
+      mock(Railsthemes::Utils).get_primary_configuration { ['haml', 'scss'] }
+      result = @installer.get_download_hash 'panozzaj@gmail.com:code'
+      result.should == { 'theme' => 'auth_url' }
     end
 
-    it 'should return an error message on any HTTP errors' do
-      FakeWeb.register_uri :get, /\/installer\/version$/,
+    it 'should fail with an error message on any error message' do
+      FakeWeb.register_uri :get,
+        'https://railsthemes.com/download?code=panozzaj@gmail.com:code&config=',
         :body => '', :status => ['401', 'Unauthorized']
-      @installer.check_installer_version.should_not be_nil
-    end
-  end
-
-  describe '#install_from_server' do
-    context 'when a gemfile.lock is present' do
-      before do
-        mock(@installer).send_gemfile('panozzaj@gmail.com:code')
-      end
-
-      it 'should download the file correctly when valid configuration' do
-        FakeWeb.register_uri :get,
-          /download\?code=panozzaj@gmail.com:code&config=haml,scss/,
-          :body => 'auth_url'
-        mock(@installer).get_primary_configuration('') { 'haml,scss' }
-        mock(Railsthemes::Utils).download_file_to('auth_url', "#{@tempdir}/archive.tar.gz")
-        mock(@installer).install_from_archive "#{@tempdir}/archive.tar.gz"
-        @installer.install_from_server 'panozzaj@gmail.com:code'
-      end
-
-      it 'should fail with an error message on any error message' do
-        FakeWeb.register_uri :get,
-          'https://railsthemes.com/download?code=panozzaj@gmail.com:code&config=',
-          :body => '', :status => ['401', 'Unauthorized']
-        mock(@installer).get_primary_configuration('') { '' }
-        mock(Railsthemes::Safe).log_and_abort(/didn't recognize/)
-        @installer.install_from_server 'panozzaj@gmail.com:code'
-      end
-    end
-  end
-
-  describe '#get_primary_configuration' do
-    it 'should give erb,css when there is no Gemfile' do
-      @installer.get_primary_configuration('').should == 'erb,css'
-    end
-
-    it 'should give haml,scss when haml and sass are in the Gemfile' do
-      gemfile = using_gems 'haml', 'sass'
-      @installer.get_primary_configuration(gemfile).should == 'haml,scss'
-    end
-
-    it 'should give haml,css when sass is not in the Gemfile but haml is' do
-      gemfile = using_gems 'haml'
-      @installer.get_primary_configuration(gemfile).should == 'haml,css'
-    end
-
-    it 'should give erb,scss when haml is not in the gemfile but sass is' do
-      gemfile = using_gems 'sass'
-      @installer.get_primary_configuration(gemfile).should == 'erb,scss'
-    end
-
-    it 'should give erb,css when haml and sass are not in the gemfile' do
-      gemfile = using_gems
-      @installer.get_primary_configuration(gemfile).should == 'erb,css'
+      mock(Railsthemes::Utils).get_primary_configuration { [] }
+      mock(Railsthemes::Safe).log_and_abort(/didn't recognize/)
+      @installer.install_from_code 'panozzaj@gmail.com:code'
     end
   end
 
-  describe :check_vcs_status do
-    context 'when Git used' do
-      before do
-        Dir.mkdir('.git')
-      end
-
-      it 'should return false, issues when the vcs is unclean' do
-        mock(Railsthemes::Safe).system_call('git status -s') { '# modified: installer_spec.rb' }
-        result = @installer.check_vcs_status
-        result.should match /Git reports/
-        result.should match /# modified: installer_spec\.rb/
-        result.should match /roll back or commit/
-      end
-
-      it 'should do nothing significant when the vcs is clean' do
-        mock(Railsthemes::Safe).system_call('git status -s') { '' }
-        @installer.check_vcs_status.should be_nil
-      end
-    end
-
-    context 'when Mercurial used' do
-      before do
-        Dir.mkdir('.hg')
-      end
-
-      it 'should exit when the vcs is unclean' do
-        mock(Railsthemes::Safe).system_call('hg status') { '? test.txt' }
-        result = @installer.check_vcs_status
-        result.should_not be_nil
-        result.should match /Mercurial reports/
-        result.should match /\? test\.txt/
-        result.should match /roll back or commit/
-      end
-
-      it 'should do nothing significant when the vcs is clean' do
-        mock(Railsthemes::Safe).system_call('hg status') { '' }
-        @installer.check_vcs_status.should be_nil
+  describe :send_gemfile do
+    context 'without Gemfile.lock present' do
+      it 'should not hit the server and should return nil' do
+        result = @installer.send_gemfile('panozzaj@gmail.com:code')
+        result.should be_nil
       end
     end
 
-    context 'when Subversion used' do
+    context 'with Gemfile.lock present' do
       before do
-        Dir.mkdir('.svn')
+        File.open('Gemfile.lock', 'w') do |file|
+          file.puts "GEM\n  remote: https://rubygems.org/"
+        end
       end
 
-      it 'should exit when the vcs is unclean' do
-        mock(Railsthemes::Safe).system_call('svn status') { 'M something.txt' }
-        result = @installer.check_vcs_status
-        result.should match /Subversion reports/
-        result.should match /M something\.txt/
-        result.should match /roll back or commit/
+      it 'should hit the server with the Gemfile and return the results, arrayified' do
+        FakeFS.deactivate! # has an issue with generating tmpfiles otherwise
+        params = { :code => 'panozzaj@gmail.com:code', :gemfile_lock => File.new('Gemfile.lock', 'rb') }
+        FakeWeb.register_uri :post, 'https://railsthemes.com/gemfiles/parse',
+          :body => 'haml,scss', :parameters => params
+        @installer.send_gemfile('panozzaj@gmail.com:code')
       end
 
-      it 'should do nothing significant when the vcs is clean' do
-        mock(Railsthemes::Safe).system_call('svn status') { '' }
-        @installer.check_vcs_status.should be_nil
+      it 'should return a blank array when there are issues' do
+        FakeFS.deactivate! # has an issue with generating tmpfiles otherwise
+        FakeWeb.register_uri :post, 'https://railsthemes.com/gemfiles/parse',
+          :body => '', :parameters => :any, :status => ['401', 'Unauthorized']
+        @installer.send_gemfile('panozzaj@gmail.com:code')
       end
     end
   end
 
-  describe '#create_railsthemes_demo_pages' do
-    before do
-      FileUtils.mkdir('config')
-      File.open(File.join('config', 'routes.rb'), 'w') do |f|
-        f.write <<-EOS
-RailsApp::Application.routes.draw do
-  # This is a legacy wild controller route that's not recommended for RESTful applications.
-  # Note: This route will make all actions in every controller accessible via GET requests.
-  # match ':controller(/:action(/:id(.:format)))'
-end
-        EOS
-      end
-    end
-
-    it 'should create a RailsThemes controller' do
-      @installer.create_railsthemes_demo_pages
-      controller = File.join('app', 'controllers', 'railsthemes_controller.rb')
-      lines = File.read(controller).split("\n")
-      lines.count.should == 11
-      lines.first.should match /class RailsthemesController < ApplicationController/
-    end
-
-    it 'should insert lines into the routes file' do
-      @installer.create_railsthemes_demo_pages
-      routes_file = File.join('config', 'routes.rb')
-      lines = File.read(routes_file).split("\n")
-      lines.grep(/match 'railsthemes\/landing' => 'railsthemes#landing'/).count.should == 1
-      lines.grep(/match 'railsthemes\/inner' => 'railsthemes#inner'/).count.should == 1
-      lines.grep(/match 'railsthemes\/jquery_ui' => 'railsthemes#jquery_ui'/).count.should == 1
-    end
-
-    it 'should not insert lines into the routes file when run more than once' do
-      @installer.create_railsthemes_demo_pages
-      @installer.create_railsthemes_demo_pages
-      routes_file = File.join('config', 'routes.rb')
-      lines = File.read(routes_file).split("\n")
-      lines.grep(/match 'railsthemes\/landing' => 'railsthemes#landing'/).count.should == 1
-      lines.grep(/match 'railsthemes\/inner' => 'railsthemes#inner'/).count.should == 1
-      lines.grep(/match 'railsthemes\/jquery_ui' => 'railsthemes#jquery_ui'/).count.should == 1
-    end
-  end
-
-  describe '#rails_version' do
-    it 'should return the right version' do
-      gemfile = using_gem_specs :rails => '3.0.1'
-      @installer.rails_version(gemfile).version.should == '3.0.1'
-    end
-
-    it 'should return nil if there is no rails present' do
-      gemfile = using_gem_specs
-      @installer.rails_version(gemfile).should be_nil
-    end
-  end
-
-  describe 'popup_documentation' do
-    it 'should not open if the style guide does not exist' do
-      dont_allow(Launchy).open(anything)
-      @installer.popup_documentation
-    end
-
-    it 'should open the style guide correctly if it exists' do
-      FileUtils.mkdir_p('doc')
-      filename = 'doc/Theme_Envy_Usage_And_Style_Guide.html'
-      FileUtils.touch(filename)
-      mock(Launchy).open(filename)
-      @installer.popup_documentation
-    end
-  end
 end