webbynode 0.1.2 → 0.2.0

data/spec/webbynode/commands/config_spec.rb

@@ -0,0 +1,22 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Commands::Config do
+  let(:api) { double("ApiClient") }
+  
+  it "should write ~/.webbynode config file" do
+    api.should_receive(:init_credentials).with({})
+    
+    cmd = Webbynode::Commands::Config.new
+    cmd.should_receive(:api).any_number_of_times.and_return(api)
+    cmd.run
+  end
+  
+  it "should write ~/.webbynode config file" do
+    api.should_receive(:init_credentials).with({ :email => "email", :token => 'token'} )
+    
+    cmd = Webbynode::Commands::Config.new("--email=email", "--token=token")
+    cmd.should_receive(:api).any_number_of_times.and_return(api)
+    cmd.run
+  end
+end

data/spec/webbynode/commands/delete_spec.rb

@@ -0,0 +1,78 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Commands::Delete do
+  let(:cmd)     { Webbynode::Commands::Delete.new }
+  let(:pushand) { double("PushAnd").as_null_object }
+  let(:re)      { double("RemoteExecutor").as_null_object }
+  let(:io)      { double("Io").as_null_object }
+  
+  def setup_mocks(cmd)
+    cmd.should_receive(:pushand).any_number_of_times.and_return(pushand)
+    cmd.should_receive(:remote_executor).any_number_of_times.and_return(re)
+    cmd.should_receive(:io).any_number_of_times.and_return(io)
+  end
+  
+  before do
+    setup_mocks(cmd)
+  end
+  
+  it "should run delete_app for the current application" do
+    pushand.should_receive(:parse_remote_app_name).and_return("myapp")
+    re.should_receive(:exec).with("delete_app myapp --force", true)
+    cmd.should_receive(:ask).with("Do you really want to delete application myapp (y/n)? ").and_return("y") 
+    cmd.run
+  end
+  
+  context "when pushand doesn't exist" do
+    it "should poop an easter egg" do
+      pushand.should_receive(:present?).and_return(false)
+      io.should_receive(:log).with("Ahn!? Hello, McFly, anybody home?", true)
+      cmd.stub!(:ask).any_number_of_times
+      cmd.ask.stub!(:downcase)
+      cmd.execute
+    end
+  end
+  
+  context "when pushand exists" do
+    it "should not poop an easter egg" do
+      pushand.should_receive(:present?).and_return(true)
+      io.should_not_receive(:log).with("Ahn!? Hello, McFly, anybody home?", true)
+      cmd.stub!(:ask).any_number_of_times
+      cmd.ask.stub!(:downcase)
+      cmd.execute
+    end
+  end
+  
+  it "should delete if user responds Y" do
+    pushand.should_receive(:parse_remote_app_name).and_return("myapp")
+    re.should_receive(:exec).with("delete_app myapp --force", true)
+    cmd.should_receive(:ask).with("Do you really want to delete application myapp (y/n)? ").and_return("Y") 
+    cmd.run
+  end
+  
+  it "should delete if force option is given" do
+    cmd = Webbynode::Commands::Delete.new("--force")
+    pushand.should_receive(:parse_remote_app_name).and_return("myapp")
+    re.should_receive(:exec).with("delete_app myapp --force", true)
+    setup_mocks(cmd)
+    
+    cmd.run
+  end
+  
+  it "should ask for confirmation" do
+    pushand.should_receive(:parse_remote_app_name).and_return("myapp")
+    re.should_receive(:exec).never
+    cmd.should_receive(:puts).with("Aborted.")
+    cmd.should_receive(:ask).with("Do you really want to delete application myapp (y/n)? ").and_return("n")
+    cmd.run
+  end
+  
+  it "abort if user didn't respond y" do
+    pushand.should_receive(:parse_remote_app_name).and_return("myapp")
+    re.should_receive(:exec).never
+    cmd.should_receive(:puts).with("Aborted.")
+    cmd.should_receive(:ask).with("Do you really want to delete application myapp (y/n)? ").and_return("X")
+    cmd.run
+  end
+end

data/spec/webbynode/commands/help_spec.rb

@@ -0,0 +1,43 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Commands::Help do
+  it "should print the usage, the options and the parameters for a command" do
+    CommandHelp = Class.new(Webbynode::Command)
+    CommandHelp.summary "Provides help"
+    CommandHelp.parameter :name, "My name"
+    CommandHelp.parameter :age, "My age"
+    CommandHelp.option :force, "Should I force?"
+    
+    CommandHelp.should_receive(:usage).and_return("usage")
+    CommandHelp.should_receive(:params_help).and_return("params")
+    CommandHelp.should_receive(:options_help).and_return("options")
+
+    cmd = Webbynode::Commands::Help.new("command_help")
+    cmd.run
+    
+    stdout =~ /Provides help/
+    stdout =~ /usage/
+    stdout =~ /params/
+    stdout =~ /options/
+  end
+
+  it "should print only the usage, when no commands or params" do
+    AnotherCommandHelp = Class.new(Webbynode::Command)
+    AnotherCommandHelp.summary "Provides even more help"
+
+    AnotherCommandHelp.should_receive(:summary_help).twice.and_return("Provides even more help")
+    AnotherCommandHelp.should_receive(:usage).and_return("usage")
+    AnotherCommandHelp.should_receive(:params_help).never
+    AnotherCommandHelp.should_receive(:options_help).never
+
+    cmd = Webbynode::Commands::Help.new("another_command_help")
+    cmd.run
+    
+    stdout =~ /Provides even more help/
+    stdout =~ /summary/
+    stdout =~ /usage/
+    stdout =~ /params/
+    stdout =~ /options/
+  end
+end

data/spec/webbynode/commands/init_spec.rb

@@ -0,0 +1,326 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Commands::Init do
+  let(:git_handler) { double("dummy_git_handler").as_null_object }
+  let(:io_handler)  { double("dummy_io_handler").as_null_object }
+  
+  def create_init(ip="4.3.2.1", host=nil, extra=[])
+    @command = Webbynode::Commands::Init.new(ip, host, *extra)
+    @command.should_receive(:git).any_number_of_times.and_return(git_handler) 
+    @command.should_receive(:io).any_number_of_times.and_return(io_handler)
+  end
+  
+  before(:each) do
+    FakeWeb.clean_registry
+    create_init
+  end
+  
+  context "selecting an engine" do
+    it "should create the .webbynode/engine file" do
+      command = Webbynode::Commands::Init.new("10.0.1.1", "--engine=php")
+      command.option(:engine).should == 'php'
+      command.should_receive(:io).any_number_of_times.and_return(io_handler)
+
+      io_handler.should_receive(:add_setting).with("engine", "php")
+      command.run
+    end
+  end
+  
+  context "when creating a DNS entry with --adddns option" do
+    let(:io) { io = double("Io").as_null_object }
+
+    def create_init(ip="4.3.2.1", host=nil, extra=[])
+      @command = Webbynode::Commands::Init.new(ip, host, *extra)
+      @command.should_receive(:git).any_number_of_times.and_return(git_handler) 
+    end
+
+    it "should setup DNS using Webbynode API" do
+      create_init("10.0.1.1", "new.rubyista.info", "--adddns")
+
+      io.should_receive(:remove_setting).with("dns_alias")
+
+      api = Webbynode::ApiClient.new
+      api.should_receive(:create_record).with("new.rubyista.info", "10.0.1.1")
+      git_handler.should_receive(:parse_remote_ip).and_return("10.0.1.1")
+
+      @command.should_receive(:api).any_number_of_times.and_return(api)
+      @command.should_receive(:io).any_number_of_times.and_return(io)
+      @command.run
+    end
+
+    it "should setup empty and www records for a tld" do
+      create_init("10.0.1.1", "rubyista.info", "--adddns")
+
+      io.should_receive(:add_setting).with("dns_alias", "'www.rubyista.info'")
+
+      api = Webbynode::ApiClient.new
+      api.should_receive(:create_record).with("rubyista.info", "10.0.1.1")
+      api.should_receive(:create_record).with("www.rubyista.info", "10.0.1.1")
+      git_handler.should_receive(:parse_remote_ip).any_number_of_times.and_return("10.0.1.1")
+
+      @command.should_receive(:api).any_number_of_times.and_return(api)
+      @command.should_receive(:io).any_number_of_times.and_return(io)
+      @command.run
+    end
+
+    it "should setup empty and www records for a non-.com tld" do
+      create_init("10.0.1.1", "rubyista.com.br", "--adddns")
+
+      # io = double("Io")
+      # io.should_receive(:properties).with(".webbynode/settings").and_return(stub("Properties"))
+
+      api = Webbynode::ApiClient.new
+      api.should_receive(:create_record).with("rubyista.com.br", "10.0.1.1")
+      api.should_receive(:create_record).with("www.rubyista.com.br", "10.0.1.1")
+      git_handler.should_receive(:parse_remote_ip).any_number_of_times.and_return("10.0.1.1")
+
+      @command.should_receive(:io).any_number_of_times.and_return(io)
+      @command.should_receive(:api).any_number_of_times.and_return(api)
+      @command.run
+    end
+
+    it "should indicate the record already exists" do
+      create_init("10.0.1.1", "new.rubyista.info", "--adddns")
+
+      api = Webbynode::ApiClient.new
+      api.should_receive(:create_record).with("new.rubyista.info", "10.0.1.1").and_raise(Webbynode::ApiClient::ApiError.new("Data has already been taken"))
+      git_handler.should_receive(:parse_remote_ip).and_return("10.0.1.1")
+
+      # the DNS setting should remove any dns_aliases on .webbynode/settings
+      io = Webbynode::Io.new
+      io.should_receive(:remove_setting).with("dns_alias")
+
+      @command.should_receive(:api).any_number_of_times.and_return(api)
+      @command.should_receive(:io).any_number_of_times.and_return(io)
+      @command.run
+      
+      stdout.should =~ /The DNS entry for 'new.rubyista.info' already existed, ignoring./
+    end
+
+    it "should show an user friendly error" do
+      create_init("10.0.1.1", "new.rubyista.info", "--adddns")
+
+      api = Webbynode::ApiClient.new
+      git_handler.should_receive(:parse_remote_ip).and_return("10.0.1.1")
+      api.should_receive(:create_record).with("new.rubyista.info", "10.0.1.1").and_raise(Webbynode::ApiClient::ApiError.new("No DNS entry for id 99999"))
+
+      # the DNS setting should remove any dns_aliases on .webbynode/settings
+      io = Webbynode::Io.new
+      io.should_receive(:remove_setting).with("dns_alias")
+
+      @command.should_receive(:api).any_number_of_times.and_return(api)
+      @command.should_receive(:io).any_number_of_times.and_return(io)
+      @command.run
+      
+      stdout.should =~ /Couldn't create your DNS entry: No DNS entry for id 99999/
+    end
+  end
+  
+  it "should ask for user's login email if no credentials" do
+    FakeWeb.register_uri(:post, "#{Webbynode::ApiClient.base_uri}/webbies", 
+      :email => "fcoury@me.com", :response => read_fixture("api/webbies"))
+
+    io_handler.should_receive(:file_exists?).with(Webbynode::ApiClient::CREDENTIALS_FILE).and_return(false)
+    io_handler.should_receive(:app_name).any_number_of_times.and_return("my_app")
+
+    props = {}
+    props.stub(:save)
+
+    create_init("my_webby_name")
+    @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")
+    @command.api.should_receive(:properties).any_number_of_times.and_return(props)
+    @command.run
+    
+    stdout.should =~ /Couldn't find Webby 'my_webby_name' on your account. Your Webbies are/
+    stdout.should =~ /'webby3067'/
+    stdout.should =~ /' and '/
+    stdout.should =~ /'sandbox'/
+  end
+  
+  it "should report the error if user provides wrong credentials" do
+    FakeWeb.register_uri(:post, "#{Webbynode::ApiClient.base_uri}/webbies", 
+      :email => "fcoury@me.com", :response => read_fixture("api/webbies_unauthorized"))
+
+    io_handler.should_receive(:app_name).any_number_of_times.and_return("my_app")
+    io_handler.should_receive(:create_file).never
+
+    create_init("my_webby_name")
+
+    @command.api.should_receive(:ip_for).and_raise(Webbynode::ApiClient::Unauthorized)
+    @command.run
+
+    stdout.should =~ /Your credentials didn't match any Webbynode account./
+  end
+  
+  it "should report Webby doesn't exist" do
+    api = double("ApiClient")
+    api.should_receive(:ip_for).with("my_webby_name").and_return(nil)
+    api.should_receive(:webbies).and_return({
+      "one_webby"=>{:name => 'one_webby', :other => 'other'}, 
+      "another_webby"=>{:name => 'another_webby', :other => 'other'}
+    })
+    
+    io_handler.should_receive(:app_name).any_number_of_times.and_return("my_app")
+
+    create_init("my_webby_name")
+    @command.should_receive(:api).any_number_of_times.and_return(api)
+    @command.run
+    
+    stdout.should =~ /Couldn't find Webby 'my_webby_name' on your account. Your Webbies are/
+    stdout.should =~ /'one_webby'/
+    stdout.should =~ /' and '/
+    stdout.should =~ /'another_webby'/
+  end
+  
+  it "should report user doesn't have Webbies" do
+    api = double("ApiClient")
+    api.should_receive(:ip_for).with("my_webby_name").and_return(nil)
+    api.should_receive(:webbies).and_return({})
+    
+    io_handler.should_receive(:app_name).any_number_of_times.and_return("my_app")
+
+    create_init("my_webby_name")
+    @command.should_receive(:api).any_number_of_times.and_return(api)
+    @command.run
+    
+    stdout.should =~ /You don't have any active Webbies on your account./
+  end
+  
+  it "should try to get Webby's IP if no IP given" do
+    api = double("ApiClient")
+    api.should_receive(:ip_for).with("my_webby_name").and_return("1.2.3.4")
+    
+    io_handler.should_receive(:app_name).any_number_of_times.and_return("my_app")
+    git_handler.should_receive(:present?).and_return(false)
+    git_handler.should_receive(:add_remote).with("webbynode", "1.2.3.4", "my_app")
+
+    create_init("my_webby_name")
+    @command.should_receive(:api).and_return(api)
+    @command.run
+  end
+  
+  context "determining host" do
+    it "should assume host is app's name when not given" do
+      io_handler.should_receive(:file_exists?).with(".pushand").and_return(false)
+      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.run
+    end
+  
+    it "should assume host is app's name when not given" do
+      create_init("1.2.3.4", "my.com.br")
+      
+      io_handler.should_receive(:file_exists?).with(".pushand").and_return(false)
+      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 .webbynode is not present" do
+    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(:exec).with("mkdir -p .webbynode/tasks")
+      io_handler.should_receive(:create_file).with(".webbynode/tasks/after_push", "")
+      io_handler.should_receive(:create_file).with(".webbynode/tasks/before_push", "")
+      io_handler.should_receive(:create_file).with(".webbynode/aliases", "")
+      
+      @command.run
+    end
+  end
+  
+  context "when .pushand is not present" do
+    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")
+      io_handler.should_receive(:create_file).with(".pushand", "#! /bin/bash\nphd $0 mah_app mah_app\n", true)
+      
+      @command.run
+    end
+  end
+  
+  context "when .pushand is present" do
+    it "should not be created" do
+      io_handler.should_receive(:file_exists?).with(".pushand").and_return(true)
+      io_handler.should_receive(:create_file).never
+      
+      @command.run
+    end
+  end
+  
+  context "when git repo doesn't exist yet" do
+    it "should create a new git repo" do
+      git_handler.should_receive(:present?).and_return(false)
+      git_handler.should_receive(:init)
+
+      @command.run
+    end
+    
+    it "should add a new remote" do
+      io_handler.should_receive(:app_name).any_number_of_times.and_return("my_app")
+      git_handler.should_receive(:present?).and_return(false)
+      git_handler.should_receive(:add_remote).with("webbynode", "4.3.2.1", "my_app")
+
+      @command.run
+    end
+    
+    it "should add everything" do
+      git_handler.should_receive(:present?).and_return(false)
+      git_handler.should_receive(:add).with(".")
+
+      @command.run
+    end
+  
+    it "should create the initial commit" do
+      git_handler.should_receive(:present?).and_return(false)
+      git_handler.should_receive(:commit).with("Initial commit")
+      
+      @command.run
+    end
+    
+    it "should log a message to the user when it's finished" do
+      io_handler.should_receive(:app_name).any_number_of_times.and_return("my_app")
+      io_handler.should_receive(:log).with("Application my_app ready for Rapid Deployment", :finish)
+      
+      @command.run
+    end
+  end
+
+  context "when git repo is initialized" do
+    it "should not create a commit" do
+      git_handler.should_receive(:present?).and_return(true)
+      git_handler.should_receive(:commit).never
+
+      @command.run
+    end
+
+    it "should try to add a remote" do
+      git_handler.should_receive(:present?).and_return(true)
+      git_handler.should_receive(:add_remote)
+
+      @command.run
+    end
+    
+    it "should tell the user it's already initialized" do
+      git_handler.should_receive(:present?).and_return(true)
+      git_handler.should_receive(:add_remote).and_raise(Webbynode::GitRemoteAlreadyExistsError)
+      
+      io_handler.should_receive(:log).with("Application already initialized.", true)
+      @command.run
+    end
+  end
+end

data/spec/webbynode/commands/push_spec.rb

@@ -0,0 +1,175 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Commands::Push do
+
+  let(:push)    { Webbynode::Commands::Push.new }
+  let(:io)      { double('Io').as_null_object }
+  let(:re)      { double('RemoteExecutor').as_null_object }
+  let(:pushand) { double('PushAnd').as_null_object }
+  let(:git)     { double('Git').as_null_object }
+
+  before(:each) do
+    push.should_receive(:io).any_number_of_times.and_return(io)
+    push.should_receive(:remote_executor).any_number_of_times.and_return(re)
+    push.should_receive(:pushand).any_number_of_times.and_return(pushand)
+    push.should_receive(:git).any_number_of_times.and_return(git)
+    push.before_tasks.stub!(:read_tasks)
+    push.after_tasks.stub!(:read_tasks)
+  end
+  
+  context "when the user runs the command" do
+    it "should display a message that the application is being pushed to the webby" do
+      pushand.should_receive(:parse_remote_app_name).and_return("test.webbynode.com")
+      io.should_receive(:log).with("Pushing test.webbynode.com", :start)
+      push.stub!(:exec)
+      push.execute
+    end
+    
+    it "should push the application to the webby" do
+      io.should_receive(:exec).with("git push webbynode master", false)
+      push.execute
+    end
+    
+    it "should not push and warn the user if git status is not clean" do
+      git.should_receive(:clean?).and_return(false)
+      lambda { push.execute }.should raise_error(Webbynode::Command::CommandError,
+        "Cannot push because you have pending changes. Do a git commit or add changes to .gitignore.")
+    end
+    
+    it "should not push and warn the user if git status is not clean and the user uses --dirty" do
+      pushcmd = Webbynode::Commands::Push.new("--dirty")
+      pushcmd.should_receive(:io).any_number_of_times.and_return(io)
+      pushcmd.should_receive(:remote_executor).any_number_of_times.and_return(re)
+      pushcmd.should_receive(:pushand).any_number_of_times.and_return(pushand)
+      pushcmd.should_receive(:git).any_number_of_times.and_return(git)
+      pushcmd.before_tasks.stub!(:read_tasks)
+      pushcmd.after_tasks.stub!(:read_tasks)
+
+      pushand.should_receive(:parse_remote_app_name).and_return("app")
+      io.should_receive(:log).with("Finished pushing app", :finish)
+      git.should_receive(:clean?).never
+
+      pushcmd.execute
+    end
+    
+    context "when succesful" do
+      it "should notify the user" do
+        pushand.should_receive(:parse_remote_app_name).and_return("test.webbynode.com")
+        io.should_receive(:log).with("Finished pushing test.webbynode.com", :finish)
+        push.execute
+      end
+    end
+    
+    describe "Tasks" do
+      it "should have 2 before_tasks present" do
+        push.execute
+        2.times { push.before_tasks.session_tasks << "foo" }
+        push.before_tasks.session_tasks.should have(2).session_tasks
+        push.before_tasks.should be_an_instance_of(Webbynode::Commands::Tasks)
+      end
+    
+      it "should have 2 after_tasks present" do
+        push.execute
+        2.times { push.after_tasks.session_tasks << "foo" }
+        push.after_tasks.session_tasks.should have(2).session_tasks
+        push.after_tasks.should be_an_instance_of(Webbynode::Commands::Tasks)
+      end
+      
+      it "should read the tasks files to see whether there are tasks available" do
+        push.before_tasks.should_receive(:read_tasks).with(Webbynode::Commands::Tasks::BeforePushTasksFile)
+        push.after_tasks.should_receive(:read_tasks).with(Webbynode::Commands::Tasks::AfterPushTasksFile)
+        push.execute
+      end
+      
+      it "should check if there are any before_tasks or after_tasks" do
+        push.before_tasks.should_receive(:has_tasks?)
+        push.after_tasks.should_receive(:has_tasks?)
+        push.execute
+      end
+      
+      it "should ensure that there are at least blank files available to read from" do
+        push.before_tasks.should_receive(:ensure_tasks_folder)
+        push.execute
+      end
+      
+      it "should not initialize the before_tasks if there aren't any tasks to perform" do
+        push.before_tasks.should_receive(:has_tasks?).and_return(false)
+        push.should_not_receive(:perform_before_tasks)
+        push.execute
+      end
+      
+      it "should not initialize the after_tasks if there aren't any tasks to perform" do
+        push.after_tasks.should_receive(:has_tasks?).and_return(false)
+        push.should_not_receive(:perform_after_tasks)
+        push.execute
+      end
+    end
+    
+    describe "before_push tasks" do
+      context "when there are one or more tasks available" do
+        before(:each) do
+          push.before_tasks.stub!(:has_tasks?).and_return(true)
+        end
+        
+        it "should perform these tasks in order" do
+          push.should_receive(:perform_before_tasks)
+          push.execute
+        end
+      end
+    end
+    
+    describe "after_push tasks" do
+      context "when there are one or more tasks available" do
+        before(:each) do
+          push.after_tasks.stub!(:has_tasks?).and_return(true)
+        end
+        
+        it "should perform these tasks in order" do
+          push.should_receive(:perform_after_tasks)
+          push.execute
+        end
+      end
+    end
+    
+    describe "#perform_before_tasks" do
+      before(:each) do
+        push.before_tasks.stub!(:has_tasks?).and_return(true)
+        io.stub!(:exec).with("git push webbynode master")
+      end
+      
+      it "should provide feedback to the user that it's going to perform the tasks" do
+        io.should_receive(:log).with("Performing Before Push Tasks...", :action)
+        push.execute
+      end
+      
+      it "should loop through each of the tasks, perform them and provide feedback" do
+        3.times { |n| push.before_tasks.session_tasks << "Task #{n}" }
+        3.times { |n| io.should_receive(:exec).exactly(:once).with("Task #{n}") }
+        3.times { |n| io.should_receive(:log).exactly(:once).with("  Performing Task: Task #{n}", :action)}
+        push.execute
+      end
+    end
+    
+    describe "#perform_after_tasks" do
+      before(:each) do
+        push.after_tasks.stub!(:has_tasks?).and_return(true)
+        io.stub!(:exec).with("git push webbynode master")
+      end
+      
+      it "should provide feedback to the user that it's going to perform the tasks" do
+        io.should_receive(:log).with("Performing After Push Tasks...", :action)
+        push.execute
+      end
+      
+      it "should loop through each of the tasks, perform them and provide feedback" do
+        3.times { |n| push.after_tasks.session_tasks << "Task #{n}" }
+        3.times { |n| re.should_receive(:exec).exactly(:once).with("cd test.webbynode.com; Task #{n}", true) }
+        3.times { |n| io.should_receive(:log).exactly(:once).with("  Performing Task: Task #{n}", :action) }
+        pushand.should_receive(:parse_remote_app_name).exactly(4).times.and_return("test.webbynode.com")
+        push.execute
+      end
+    end
+    
+  end
+end