webbynode 0.2.5.beta1 → 0.2.5.beta2

data/spec/webbynode/commands/init_spec.rb

@@ -5,6 +5,7 @@ describe Webbynode::Commands::Init do
   let(:git_handler) { double("git").as_null_object }
   let(:io_handler)  { double("io").as_null_object }
   let(:gemfile)     { double("gemfile").as_null_object.tap { |g| g.stub!(:present?).and_return(false) } }
+  let(:api)         { double("api").as_null_object }
   
   def create_init(ip="4.3.2.1", host=nil, extra=[])
     host = "--dns=#{host}" if host
@@ -20,44 +21,184 @@ describe Webbynode::Commands::Init do
     git_handler.stub!(:remote_exists?).and_return(false)
   end
   
-  context 'Checking prerequisites' do
-    subject do
-      Webbynode::Commands::Init.new.tap do |cmd|
-        cmd.stub!(:git).and_return(git_handler)
-        cmd.stub!(:io).and_return(io_handler)
-      end      
+  subject do
+    Webbynode::Commands::Init.new.tap do |cmd|
+      webbies = {
+        'sandbox' => {
+          :ip     => "201.81.121.201",
+          :status => "on",
+          :name   => "sandbox",
+          :notes  => "",
+          :plan   => "Webbybeta",
+          :node   => "miami-b15"
+        }
+      }
+      api.stub!(:webbies).and_return(webbies)
+
+      cmd.stub!(:git).and_return(git_handler)
+      cmd.stub!(:io).and_return(io_handler)
+      cmd.stub!(:api).and_return(api)
+    end      
+  end
+  
+  describe '#detect_engine' do
+    before(:each) do
+      subject.stub!(:io).and_return(io_handler)
+    end
+    
+    it "calls prepare once engine is detected" do
+      subject.stub!(:option).with(:engine).and_return('rails')
+      io_handler.should_receive(:add_setting).with('engine', 'rails')
+      
+      rails = double('Rails')
+      rails.should_receive(:prepare)
+
+      Webbynode::Engines::Rails.should_receive(:new).and_return(rails)
+      subject.send(:detect_engine)
     end
 
+    context 'when --engine is passed' do
+      it "adds an engine setting" do
+        io_handler.should_receive(:add_setting).with('engine', 'rails')
+        io_handler.stub!(:add_to_git_ignore)
+        
+        Webbynode::Git.stub(:new).and_return(git_handler)
+        
+        subject.stub!(:option).with(:engine).and_return('rails')
+        subject.send(:detect_engine)
+      end
+    
+      context 'with invalid engine' do
+        it "reports the error and show engines for user to choose" do
+          subject.stub!(:option).with(:engine).and_return('kawaboonga')
+
+          io_handler.should_receive(:add_setting).with('engine', 'django')
+          io_handler.should_receive(:log).with("Engine 'kawaboonga' is invalid.")
+
+          django = stub('Django').as_null_object
+          django.should_receive(:engine_id).and_return('django')
+          
+          subject.should_receive(:choose_engine).and_return(django)
+          
+          subject.send(:detect_engine)
+        end
+      end
+    end
+  end
+
+  context 'Checking prerequisites' do
     it "raises an error if git is not found" do
       io_handler.should_receive(:exec_in_path?).with('git').and_return(false)
+      subject.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
       lambda { subject.execute }.should raise_error(Webbynode::Command::CommandError)
     end
   end
   
-  context "Deployment webby" do
-    let(:api) { double("api").as_null_object }
-    subject do
-      Webbynode::Commands::Init.new.tap do |cmd|
-        cmd.stub!(:git).and_return(git_handler)
-        cmd.stub!(:io).and_return(io_handler)
-        cmd.stub!(:api).and_return(api)
-      end      
+  context "Engine validation" do
+    context "when there is a validation error" do
+      it "displays the error and exits" do
+        
+      end
+    end
+  end
+  
+  context "Engine detection" do
+    context "when no engine was detected" do
+      it "prompts for the engine" do
+        io_handler.should_receive(:log).with("Supported engines:")
+        io_handler.should_receive(:log).with("  1. Django")
+        io_handler.should_receive(:log).with("  2. PHP")
+        io_handler.should_receive(:log).with("  3. Rack")
+        io_handler.should_receive(:log).with("  4. Rails 2")
+        io_handler.should_receive(:log).with("  5. Rails 3")
+
+        subject.should_receive(:ask).with('Select the engine your app uses:', Integer).and_return(1)
+
+        io_handler.should_receive(:add_setting).with("engine", "django")
+        io_handler.should_receive(:log).with("Initializing with Django engine...")
+        Webbynode::Engines::Django.stub!(:new).and_return(double('Django').as_null_object)
+        subject.run
+      end
     end
     
+    context "when --engine is passed" do
+      subject do
+        Webbynode::Commands::Init.new("--engine=php").tap do |cmd|
+          webbies = {
+            'sandbox' => {
+              :ip     => "201.81.121.201",
+              :status => "on",
+              :name   => "sandbox",
+              :notes  => "",
+              :plan   => "Webbybeta",
+              :node   => "miami-b15"
+            }
+          }
+          api.stub!(:webbies).and_return(webbies)
+
+          cmd.stub!(:git).and_return(git_handler)
+          cmd.stub!(:io).and_return(io_handler)
+          cmd.stub!(:api).and_return(api)
+        end      
+      end
+      
+      it "overrides detection" do
+        io_handler.should_receive(:log).with(/Engine '.*' is invalid/).never
+        io_handler.should_receive(:file_exists?).with("script/rails").never
+        io_handler.should_receive(:add_setting).with("engine", "php")
+
+        subject.run
+      end
+    end
+    
+    it "detects Rails 3 when script/rails is present" do
+      io = double("Io").as_null_object
+      io.stub!(:file_exists?).with("script/rails").and_return(true)
+      
+      gemfile = double("Gemfile").as_null_object
+      gemfile.stub!(:present?).and_return(false)
+
+      Webbynode::Gemfile.stub(:new).and_return(gemfile)
+      
+      Webbynode::Io.stub(:new).and_return(io)
+      io_handler.should_receive(:add_setting).with("engine", "rails3")
+
+      subject.run
+    end
+    
+    it "detects Rails 2 when app app/controllers and config/environent.rb are found" do
+      io = double("Io").as_null_object
+      io.stub(:file_exists?).with("script/rails").and_return(false)
+      io.stub(:directory?).with('app').and_return(true)
+      io.stub(:directory?).with('app/controllers').and_return(true)
+      io.stub(:file_exists?).with('config/environent.rb').and_return(true)
+
+      Webbynode::Io.stub(:new).and_return(io)
+      Webbynode::Git.stub(:new).and_return(git_handler)
+      io_handler.should_receive(:add_setting).with("engine", "rails")
+
+      subject.run
+    end
+    
+    it "detects Rack when config.ru is found" do
+      io = double("Io")
+      io.stub!(:file_exists?).with("script/rails").and_return(false)
+      io.stub!(:directory?).with('app').and_return(false)
+      io.stub!(:file_exists?).with('config.ru').and_return(true)
+
+      Webbynode::Io.stub!(:new).and_return(io)
+
+      io_handler.should_receive(:add_setting).with("engine", "rack")
+
+      subject.run
+    end
+  end
+  
+  context "Deployment webby" do
     it "is detected automatically if user only have one Webby" do
-      webbies = {
-        'sandbox' => {
-          :ip     => "201.81.121.201",
-          :status => "on",
-          :name   => "sandbox",
-          :notes  => "",
-          :plan   => "Webbybeta",
-          :node   => "miami-b15"
-        }
-      }
-      api.should_receive(:webbies).and_return(webbies)
       git_handler.should_receive(:add_remote).with("webbynode", "201.81.121.201", anything())
       
+      subject.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
       subject.run
     end
     
@@ -89,66 +230,45 @@ describe Webbynode::Commands::Init do
         }
       }
       api.should_receive(:webbies).and_return(webbies)
-      io_handler.should_receive(:log).with("Current Webbies in your account:", anything())
-      io_handler.should_receive(:log).with("  1. sandbox (201.81.121.201)", anything())
-      io_handler.should_receive(:log).with("  2. webby2 (67.53.31.2)", anything())
-      io_handler.should_receive(:log).with("  3. webby3 (67.53.31.3)", anything())
+      io_handler.should_receive(:log).with("Current Webbies in your account:")
+      io_handler.should_receive(:log).with("  1. sandbox (201.81.121.201)")
+      io_handler.should_receive(:log).with("  2. webby2 (67.53.31.2)")
+      io_handler.should_receive(:log).with("  3. webby3 (67.53.31.3)")
       subject.should_receive(:ask).with("Which Webby do you want to deploy to:", Integer).and_return(2)
 
-      io_handler.should_receive(:log).with("Set deployment Webby to webby2.", anything())
+      io_handler.should_receive(:log).with("Set deployment Webby to webby2.")
       git_handler.should_receive(:add_remote).with("webbynode", "67.53.31.2", anything())
       
+      subject.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
       subject.run
     end
   end
   
-  context "Gemfile checking" do
-    context "when present" do
-      it "complains if there is a sqlite3-ruby dependency outside of development and test groups" do
-        gemfile.should_receive(:present?).and_return(true)
-        gemfile.should_receive(:dependencies).and_return(['sqlite3-ruby', 'mysql'])
-        
-        lambda { @command.execute }.should raise_error(Webbynode::Command::CommandError)
-      end
-    end
-  end
-  
-  context "Rails3 auto detection" do
-    context "when script/rails is present" do
-      it "makes engine=rails3 implicitly" do
-        io_handler.stub!(:file_exists?).with("script/rails").and_return(true)
-        io_handler.should_receive(:add_setting).with("engine", "rails3")
-        
-        @command.run
+  context "when already initialized" do
+    subject do
+      Webbynode::Commands::Init.new("10.0.1.1").tap do |cmd|
+        cmd.stub!(:gemfile).and_return(gemfile)
+        cmd.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
+        cmd.stub!(:git).and_return(git_handler) 
       end
     end
-  end
-  
-  context "when already initialized" do
+    
     it "keep the same remotes when answer is no to overwriting" do
-      command = Webbynode::Commands::Init.new("10.0.1.1")
-      command.stub!(:gemfile).and_return(gemfile)
-      command.should_receive(:git).any_number_of_times.and_return(git_handler) 
-      command.should_receive(:ask).with("Do you want to overwrite the current settings (y/n)?").once.ordered.and_return("n")
-
       git_handler.should_receive(:present?).and_return(true)
       git_handler.should_receive(:remote_exists?).with("webbynode").and_return(true)
       git_handler.should_receive(:delete_remote).with("webbynode").never
       
-      command.run
+      subject.should_receive(:ask).with("Do you want to overwrite the current settings (y/n)?").once.ordered.and_return("n")
+      subject.run
     end
 
     it "delete webbynode remote when answer is yes to overwriting" do
-      command = Webbynode::Commands::Init.new("10.0.1.1")
-      command.stub!(:gemfile).and_return(gemfile)
-      command.should_receive(:git).any_number_of_times.and_return(git_handler) 
-      command.should_receive(:ask).with("Do you want to overwrite the current settings (y/n)?").once.ordered.and_return("y")
-
       git_handler.should_receive(:present?).and_return(true)
       git_handler.should_receive(:remote_exists?).with("webbynode").and_return(true)
       git_handler.should_receive(:delete_remote).with("webbynode")
       
-      command.run
+      subject.should_receive(:ask).with("Do you want to overwrite the current settings (y/n)?").once.ordered.and_return("y")
+      subject.run
     end
   end
   
@@ -171,9 +291,10 @@ describe Webbynode::Commands::Init do
     def create_init(ip="4.3.2.1", host=nil, extra=[])
       @command = Webbynode::Commands::Init.new(ip, "--dns=#{host}", *extra)
       @command.stub!(:gemfile).and_return(gemfile)
-      @command.should_receive(:git).any_number_of_times.and_return(git_handler) 
+      @command.stub!(:git).and_return(git_handler) 
+      @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
     end
-
+    
     it "should setup DNS using Webbynode API" do
       create_init("10.0.1.1", "new.rubyista.info", "--adddns")
 
@@ -267,6 +388,7 @@ describe Webbynode::Commands::Init do
     props.stub(:save)
 
     create_init("my_webby_name")
+    @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
     @command.api.should_receive(:io).any_number_of_times.and_return(io_handler)
     @command.api.should_receive(:ask).with("API token:   ").and_return("234def")
     @command.api.should_receive(:ask).with("Login email: ").and_return("abc123")
@@ -289,6 +411,7 @@ describe Webbynode::Commands::Init do
     create_init("my_webby_name")
 
     @command.api.should_receive(:ip_for).and_raise(Webbynode::ApiClient::Unauthorized)
+    @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
     @command.run
 
     stdout.should =~ /Your credentials didn't match any Webbynode account./
@@ -306,6 +429,7 @@ describe Webbynode::Commands::Init do
 
     create_init("my_webby_name")
     @command.should_receive(:api).any_number_of_times.and_return(api)
+    @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
     @command.run
     
     stdout.should =~ /Couldn't find Webby 'my_webby_name' on your account. Your Webbies are/
@@ -323,6 +447,7 @@ describe Webbynode::Commands::Init do
 
     create_init("my_webby_name")
     @command.should_receive(:api).any_number_of_times.and_return(api)
+    @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
     @command.run
     
     stdout.should =~ /You don't have any active Webbies on your account./
@@ -339,6 +464,7 @@ describe Webbynode::Commands::Init do
 
     create_init("my_webby_name")
     @command.stub!(:api).and_return(api)
+    @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
     @command.run
   end
   
@@ -348,6 +474,7 @@ describe Webbynode::Commands::Init do
       io_handler.should_receive(:app_name).any_number_of_times.and_return("application_name")
       io_handler.should_receive(:create_file).with(".pushand", "#! /bin/bash\nphd $0 application_name application_name\n", true)
     
+      @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
       @command.run
     end
   
@@ -358,65 +485,16 @@ describe Webbynode::Commands::Init do
       io_handler.should_receive(:app_name).any_number_of_times.and_return("application_name")
       io_handler.should_receive(:create_file).with(".pushand", "#! /bin/bash\nphd $0 application_name my.com.br\n", true)
     
-      @command.run
-    end
-  end
-  
-  context "when .gitignore is not present" do
-    it "should create the standard .gitignore" do
-      io_handler.should_receive(:file_exists?).with(".gitignore").and_return(false)
-      git_handler.should_receive(:add_git_ignore)
-      
-      @command.run
-    end
-  end
-  
-  context "when .gitignore is present" do
-    context "when config/database.yml is already tracked by git" do
-      it "stops tracking config/database.yml" do
-        git_handler.should_receive(:tracks?).with("config/database.yml").and_return(true)
-        git_handler.should_receive(:remove).with("config/database.yml")
-      
-        @command.run
-      end
-    end
-    
-    context "when config/database.yml is not tracked by git" do
-      it "doesn't stop tracking config/database.yml" do
-        git_handler.should_receive(:tracks?).with("config/database.yml").and_return(false)
-        git_handler.should_receive(:remove).with("config/database.yml").never
-      
-        @command.run
-      end
-    end
-    
-    context "when db/schema.rb is already tracked by git" do
-      it "stops tracking db/schema.rb" do
-        git_handler.should_receive(:tracks?).with("db/schema.rb").and_return(true)
-        git_handler.should_receive(:remove).with("db/schema.rb")
-      
-        @command.run
-      end
-    end
-    
-    context "when db/schema.rb is not tracked by git" do
-      it "doesn't stop tracking db/schema.rb" do
-        git_handler.should_receive(:tracks?).with("db/schema.rb").and_return(false)
-        git_handler.should_receive(:remove).with("db/schema.rb").never
-      
-        @command.run
-      end
-    end
-    
-    it "adds config/database.yml to .gitconfig" do
-      io_handler.should_receive(:file_exists?).with(".gitignore").and_return(true)
-      git_handler.should_receive(:add_to_git_ignore).with("config/database.yml", "db/schema.rb")
-      
+      @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
       @command.run
     end
   end
   
   context "when .webbynode is not present" do
+    before(:each) do
+      @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
+    end
+
     it "should create the .webbynode system folder and stub files" do
       io_handler.should_receive(:directory?).with(".webbynode").and_return(false)
       io_handler.should_receive(:mkdir).with(".webbynode/tasks")
@@ -429,6 +507,10 @@ describe Webbynode::Commands::Init do
   end
   
   context "when .pushand is not present" do
+    before(:each) do
+      @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
+    end
+
     it "should be created and made an executable" do
       io_handler.should_receive(:file_exists?).with(".pushand").and_return(false)
       io_handler.should_receive(:app_name).any_number_of_times.and_return("mah_app")
@@ -439,6 +521,10 @@ describe Webbynode::Commands::Init do
   end
   
   context "when .pushand is present" do
+    before(:each) do
+      @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
+    end
+
     it "should not be created" do
       io_handler.should_receive(:file_exists?).with(".pushand").and_return(true)
       io_handler.should_receive(:create_file).never
@@ -448,6 +534,10 @@ describe Webbynode::Commands::Init do
   end
   
   context "when git repo doesn't exist yet" do
+    before(:each) do
+      @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
+    end
+
     it "should create a new git repo" do
       git_handler.should_receive(:present?).and_return(false)
       git_handler.should_receive(:init)
@@ -486,6 +576,10 @@ describe Webbynode::Commands::Init do
   end
 
   context "when git repo is initialized" do
+    before(:each) do
+      @command.stub!(:detect_engine).and_return(Webbynode::Engines::Rails)
+    end
+    
     it "complains if git is in a dirty state" do
       git_handler.should_receive(:present?).and_return(true)
       git_handler.should_receive(:clean?).and_return(false)

data/spec/webbynode/engines/django_spec.rb

@@ -0,0 +1,65 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Engines::Django do
+  describe 'class methods' do
+    subject { Webbynode::Engines::Django }
+
+    its(:engine_id)    { should == 'django' }
+    its(:engine_name)  { should == 'Django' }
+    its(:git_excluded) { should == ['settings.py', '*.pyc', '*.pyo', 'docs/_build'] }
+  end
+  
+  let(:io) { double('Io') }
+  before(:each) { subject.stub!(:io).and_return(io) }
+
+  describe '#change_settings' do
+    it "calls sed to change" do
+      io.should_receive(:sed).with('settings.template.py', /'ENGINE': '[^ ,]*'/, "'ENGINE': 'engine'")
+      io.should_receive(:sed).with('settings.template.py', /'NAME': '[^ ,]*'/, "'NAME': 'name'")
+      subject.change_settings({
+        'NAME' => 'name',
+        'ENGINE' => 'engine'
+      })
+    end
+  end
+  
+  describe '#change_templates' do
+    it "calls sed to change" do
+      io.should_receive(:sed).with('settings.template.py', /TEMPLATE_DIRS = \(/, "TEMPLATE_DIRS = (\n    '@app_dir@/templates'")
+      subject.change_templates
+    end
+  end
+  
+  describe '#prepare' do
+    context "when settings.template.py doesn't exist" do
+      it "creates settings.template.py based on settings.py" do
+        io.should_receive(:file_exists?).with('settings.template.py').and_return(false)
+        io.should_receive(:copy_file).with('settings.py', 'settings.template.py')
+        io.should_receive(:log).with('Creating settings.template.py from your settings.py...')
+
+        subject.should_receive(:change_templates)
+        subject.should_receive(:change_settings).with({
+          'ENGINE' => '@app_engine@', 
+          'NAME' => '@app_name@',                      
+          'USER' => '@app_name@',                      
+          'PASSWORD' => '@app_pwd@',                  
+          'HOST' => '@db_host@',                      
+          'PORT' => '@db_port@',
+        })
+        subject.prepare
+      end
+    end
+
+    context "when settings.template.py exists" do
+      it "doesn't do anything" do
+        io.should_receive(:log).never
+        io.should_receive(:file_exists?).with('settings.template.py').and_return(true)
+        io.should_receive(:copy_file).never
+        subject.should_receive(:change_settings).never
+        subject.should_receive(:change_templates).never
+        subject.prepare
+      end
+    end
+  end
+end

data/spec/webbynode/engines/engine_spec.rb

@@ -0,0 +1,52 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Engines do
+  subject { Webbynode::Engines }
+  describe '#find' do
+    it "returns the proper engine, by engine_name" do
+      subject.find('rails').should == Webbynode::Engines::Rails
+      subject.find('rails3').should == Webbynode::Engines::Rails3
+      subject.find('django').should == Webbynode::Engines::Django
+      subject.find('rack').should == Webbynode::Engines::Rack
+      subject.find('php').should == Webbynode::Engines::Php
+    end
+  end
+end
+
+describe Webbynode::Engines::Engine do
+  let(:git) { double("Git") }
+  subject do
+    Class.new.tap do |c| 
+      c.send(:include, Webbynode::Engines::Engine)
+      c.git_excludes "config/database.yml", "db/schema.rb"
+    end.new.tap do |obj|
+      obj.stub!(:git).and_return(git)
+    end
+  end
+  
+  describe '#prepare' do    
+    it "add nontracked entries to .gitingore" do
+      git.should_receive(:remove).never
+      git.should_receive(:add_to_git_ignore).with("config/database.yml")
+      git.should_receive(:add_to_git_ignore).with("db/schema.rb")
+
+      git.stub!(:tracks?).with("config/database.yml").and_return(false)
+      git.stub!(:tracks?).with("db/schema.rb").and_return(false)
+
+      subject.prepare
+    end
+
+    it "remove tracked entries and add them to .gitingore" do
+      git.should_receive(:remove).with('config/database.yml')
+      git.should_receive(:remove).with('db/schema.rb').never
+      git.should_receive(:add_to_git_ignore).with("config/database.yml")
+      git.should_receive(:add_to_git_ignore).with("db/schema.rb")
+
+      git.stub!(:tracks?).with("config/database.yml").and_return(true)
+      git.stub!(:tracks?).with("db/schema.rb").and_return(false)
+
+      subject.prepare
+    end
+  end
+end

data/spec/webbynode/engines/php_spec.rb

@@ -0,0 +1,12 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Engines::Php do
+  describe 'class methods' do
+    subject { Webbynode::Engines::Php }
+
+    its(:engine_id)    { should == 'php' }
+    its(:engine_name)  { should == 'PHP' }
+    its(:git_excluded) { should be_empty }
+  end
+end

data/spec/webbynode/engines/rack_spec.rb

@@ -0,0 +1,34 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Engines::Rack do
+  let(:io) { double("io").as_null_object }
+
+  subject do
+    Webbynode::Engines::Rack.new.tap do |engine|
+      engine.stub!(:io).and_return(io)
+    end
+  end
+  
+  describe 'class methods' do
+    subject { Webbynode::Engines::Rack }
+
+    its(:engine_id)    { should == 'rack' }
+    its(:engine_name)  { should == 'Rack' }
+    its(:git_excluded) { should be_empty }
+  end
+  
+  describe '#detect' do
+    it "if script/rails exists" do
+      io.stub!(:file_exists?).with('config.ru').and_return(true)
+      
+      subject.should be_detected
+    end
+
+    it "fails if script/rails doesn't exist" do
+      io.stub!(:file_exists?).with('config.ru').and_return(false)
+      
+      subject.should_not be_detected
+    end
+  end
+end

data/spec/webbynode/engines/rails3_spec.rb

@@ -0,0 +1,46 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Engines::Rails3 do
+  let(:io) { double("io").as_null_object }
+
+  subject do
+    Webbynode::Engines::Rails3.new.tap do |engine|
+      engine.stub!(:io).and_return(io)
+    end
+  end
+  
+  describe 'class methods' do
+    subject { Webbynode::Engines::Rails3 }
+
+    its(:engine_id)    { should == 'rails3' }
+    its(:engine_name)  { should == 'Rails 3' }
+    its(:git_excluded) { should == ["config/database.yml", "db/schema.rb"] }
+  end
+  
+  describe '#prepare' do
+    let(:gemfile) { double('gemfile').as_null_object }
+    
+    it "complains if there is a sqlite3-ruby dependency outside of development and test groups in Gemspec" do
+      gemfile.should_receive(:present?).and_return(true)
+      gemfile.should_receive(:dependencies).and_return(['sqlite3-ruby', 'mysql'])
+
+      subject.stub!(:gemfile).and_return(gemfile)
+      lambda { subject.prepare }.should raise_error(Webbynode::Command::CommandError)
+    end
+  end
+  
+  describe '#detect' do
+    it "if script/rails exists" do
+      io.stub!(:file_exists?).with('script/rails').and_return(true)
+      
+      subject.should be_detected
+    end
+
+    it "fails if script/rails doesn't exist" do
+      io.stub!(:file_exists?).with('script/rails').and_return(false)
+      
+      subject.should_not be_detected
+    end
+  end
+end