webbynode 0.1.2 → 0.2.0

data/spec/webbynode/command_spec.rb

@@ -0,0 +1,285 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+describe Webbynode::Command do
+  let(:re)      { double("RemoteExecutor").as_null_object }
+  let(:git)     { double("Git").as_null_object }
+  let(:pushand) { double("Pushand").as_null_object }
+  let(:server)  { double("Server").as_null_object }
+  let(:ssh)     { double("SSh").as_null_object }
+  let(:io)      { double("Io").as_null_object }
+  
+  describe "resolving commands" do
+    it "should allow adding aliases to child classes" do
+      class Zap < Webbynode::Command
+        add_alias "zip"
+      end
+      
+      Webbynode::Commands.should_receive(:const_get).with("Zap")
+      Webbynode::Command.for("zip")
+    end
+    
+    it "should look for a class with the name of the command" do
+      Webbynode::Commands.should_receive(:const_get).with("Zap")
+      Webbynode::Command.for("zap")
+    end
+    
+    context "when class exists" do
+      it "should translate words separated by underscore into capitalized parts" do
+        Webbynode::Commands.should_receive(:const_get).with("RandomThoughtsIHad")
+        Webbynode::Command.for("random_thoughts_i_had")
+      end
+    end
+  end
+  
+  describe "#command" do
+    it "should return the string representation of the command" do
+      AwfulCommand = Class.new(Webbynode::Command)
+      AwfulCommand.command.should == "awful_command"
+      Amazing = Class.new(Webbynode::Command)
+      Amazing.command.should == "amazing"
+      SomeStrangeStuff = Class.new(Webbynode::Command)
+      SomeStrangeStuff.command.should == "some_strange_stuff"
+    end
+  end
+  
+  describe "#run" do
+    class RequireInitialize < Webbynode::Command
+      requires_initialization!
+      
+      def execute
+        puts "command was executed"
+      end
+    end
+    
+    context "when git is missing" do
+      it "should provide a friendly error" do
+        git.should_receive(:present?).and_return(false)
+        
+        command = RequireInitialize.new
+        command.should_receive(:remote_executor).any_number_of_times.and_return(re)
+        command.should_receive(:git).any_number_of_times.and_return(git)
+        command.should_receive(:io).any_number_of_times.and_return(io)
+        command.should_receive(:pushand).any_number_of_times.and_return(pushand)
+        command.should_receive(:server).any_number_of_times.and_return(server)
+        command.run
+        
+        stdout.should =~ /Hello, McFly, anybody home?/
+        stdout.should_not =~ /command was executed/
+      end
+    end
+  end
+  
+  describe "array of parameters" do
+    class ArrayCommand < Webbynode::Command
+      description "Initializes the current folder as a deployable application"
+      parameter :params, Array, "Name or IP of the Webby to deploy to"      
+      option :passphrase, String, "If present, passphrase will be used when creating a new SSH key", :take => :words
+    end
+    
+    it "should return an array of parameters" do
+      cmd = ArrayCommand.new("a", "b", "--passphrase=abc", "c", "d")
+      cmd.params.first.value.should == ["a", "b", "c", "d"]
+      cmd.option(:passphrase).should == "abc"
+    end
+  end
+  
+  describe "with no params" do
+    class Brief < Webbynode::Command
+    end
+    
+    it "should refuse any param" do
+      cmd = Brief.new("test")
+      cmd.run
+      stdout.should =~ /command 'brief' takes no parameters/
+    end
+  end
+  
+  describe "help for commands" do
+    class NewCommand < Webbynode::Command
+      description "Initializes the current folder as a deployable application"
+      parameter :webby, String, "Name or IP of the Webby to deploy to"
+      parameter :dns, String, "The DNS used for this application", :required => false
+      
+      option :passphrase, String, "If present, passphrase will be used when creating a new SSH key", :take => :words
+    end
+    
+    before(:each) do
+      @cmd = NewCommand.new("what!")
+    end
+    
+    it "should provide help for parameters" do
+      NewCommand.help.should =~ /Usage: webbynode new_command webby \[dns\] \[options\]/
+      NewCommand.help.should =~ /Parameters:/
+      NewCommand.help.should =~ /    webby               Name or IP of the Webby to deploy to/
+      NewCommand.help.should =~ /    dns                 The DNS used for this application, optional/
+      NewCommand.help.should =~ /Options:/
+      NewCommand.help.should =~ /    --passphrase=words  If present, passphrase will be used when creating a new SSH key/
+    end
+    
+    it "should show the help if --help option is passed" do
+      cmd = NewCommand.new("--help")
+      cmd.run
+      stdout.should =~ /Usage: webbynode new_command webby \[dns\] \[options\]/
+      stdout.should =~ /Parameters:/
+      stdout.should =~ /    webby               Name or IP of the Webby to deploy to/
+      stdout.should =~ /    dns                 The DNS used for this application, optional/
+      stdout.should =~ /Options:/
+      stdout.should =~ /    --passphrase=words  If present, passphrase will be used when creating a new SSH key/
+    end
+  end
+  
+  describe "parsing options" do
+    it "should complain about missing params and show usage" do
+      Sample = Class.new(Webbynode::Command)
+      Sample.parameter :param1, "Teste"
+      
+      cmd = Sample.new
+      cmd.run
+      
+      stdout.should =~ /Missing 'param1' parameter. Use "webbynode help sample" for more information./
+      stdout.should =~ /Usage: webbynode sample param1/
+    end
+    
+    it "should report an unknown option" do
+      Sample99 = Class.new(Webbynode::Command)
+      cmd = Sample99.new("--unknown")
+      lambda { cmd.run }.should_not raise_error
+      stdout.should =~ /Unknown option: unknown/
+    end
+    
+    it "should parse arguments as params" do
+      Sample1 = Class.new(Webbynode::Command)
+      Sample1.parameter :param1, ""
+      Sample1.parameter :param2, ""
+      
+      cmd = Sample1.new("param1", "param2")
+      cmd.params.first.value.should == "param1"
+      cmd.params.last.value.should == "param2"
+    end
+  
+    it "should parse arguments starting with -- as options" do
+      Sample2 = Class.new(Webbynode::Command)
+      Sample2.option :provided, ""
+      
+      cmd = Sample2.new("--provided=auto")
+      cmd.option(:provided).should == "auto"
+    end
+    
+    it "should parse arguments without values as true" do
+      Sample3 = Class.new(Webbynode::Command)
+      Sample3.option :force, ""
+      
+      wn = Sample3.new("--force")
+      wn.option(:force).should be_true
+    end
+    
+    it "should provide option names as symbols" do
+      Sample4 = Class.new(Webbynode::Command)
+      Sample4.option :provided, ""
+      
+      wn = Sample4.new("--provided=auto")
+      wn.option(:provided).should == "auto"
+    end
+    
+    it "should parse quoted values" do
+      Sample5 = Class.new(Webbynode::Command)
+      Sample5.option :name, ""
+
+      wn = Sample5.new("--name=\"Felipe Coury\"")
+      wn.option(:name).should == "Felipe Coury"
+    end
+  end
+  
+  describe "parsing mixed options and parameters" do
+    class Cmd < Webbynode::Command
+      parameter :param1, String, "param1"
+      parameter :param2, String, "param2"
+      option :provided, "option1"
+      option :force, "option2"
+    end
+    
+    it "should provide option names as strings and symbols" do
+      wn = Cmd.new("--provided=auto", "param1", "--force", "param2")
+      wn.option(:provided) == "auto"
+      wn.option(:force).should be_true
+      lambda { wn.option(:another) }.should raise_error(Webbynode::Command::CommandError)
+      wn.param_values.should == ["param1", "param2"]
+    end
+  end
+  
+  describe "handling Unauthorized API errors" do
+    class UnauthorizedCommand < Webbynode::Command
+      def execute
+        raise Webbynode::ApiClient::Unauthorized
+      end
+    end
+    
+    it "should output a friendly message" do
+      cmd = UnauthorizedCommand.new
+      cmd.run
+      
+      stdout.should =~ /Your credentials didn't match any Webbynode account./
+    end
+  end
+    
+  describe "parsing array parameters" do
+    class ArrayCmd < Webbynode::Command
+      parameter :param1, String, "param1"
+      parameter :param2, String, "param2"
+      parameter :param_array, Array, "array"
+      option :option, String, "descr"
+    end
+    
+    it "should parse params and all remaining as the array param" do
+      cmd = ArrayCmd.new("param1", "param2", "arr1", "arr2", "arr3", "arr4")
+      cmd.param(:param1).should == "param1"
+      cmd.param(:param2).should == "param2"
+      cmd.param(:param_array).should == ["arr1", "arr2", "arr3", "arr4"]
+    end
+
+    it "should ignore options" do
+      cmd = ArrayCmd.new("param1", "param2", "--option=tough", "arr1", "arr2", "arr3", "arr4")
+      cmd.option(:option).should == "tough"
+      cmd.param(:param1).should == "param1"
+      cmd.param(:param2).should == "param2"
+      cmd.param(:param_array).should == ["arr1", "arr2", "arr3", "arr4"]
+    end
+  end
+    
+  context "with a webbynode uninitialized application" do
+    class NewCommand < Webbynode::Command
+      requires_initialization!
+    end
+
+    before do
+      command.should_receive(:remote_executor).any_number_of_times.and_return(re)
+      command.should_receive(:git).any_number_of_times.and_return(git)
+      command.should_receive(:io).any_number_of_times.and_return(io)
+      command.should_receive(:pushand).any_number_of_times.and_return(pushand)
+      command.should_receive(:server).any_number_of_times.and_return(server)
+    end
+    
+    let(:command) { NewCommand.new("some") }
+    
+    it "should not have a git repository" do
+      git.should_receive(:present?).and_return(false)
+      lambda { command.validate_initialization }.should raise_error(Webbynode::Command::CommandError,
+        "Ahn!? Hello, McFly, anybody home?")
+    end
+    
+    it "should not have webbynode git remote" do
+      git.should_receive(:remote_webbynode?).and_return(false)
+      lambda { command.validate_initialization }.should raise_error(Webbynode::Command::CommandError,
+        "Webbynode has not been initialized for this git repository.")
+    end
+    
+    it "should not have a pushand file" do
+      git.should_receive(:present?).and_return(true)
+      io.should_receive(:directory?).with(".webbynode").and_return(true)
+      pushand.should_receive(:present?).and_return(false)
+      lambda { command.validate_initialization }.should raise_error(Webbynode::Command::CommandError,
+        "Could not find .pushand file, has Webbynode been initialized for this repository?")
+    end
+  end
+end

data/spec/webbynode/commands/add_backup_spec.rb

@@ -0,0 +1,66 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Commands::AddBackup do
+  def tie_dependencies(cmd)
+    cmd.should_receive(:io).any_number_of_times.and_return(io)
+    cmd.should_receive(:remote_executor).any_number_of_times.and_return(re)
+    cmd
+  end
+  
+  let(:io)  { double("io").as_null_object }
+  let(:re)  { double("remote_executor").as_null_object }
+  let(:cmd) { 
+    cmd = Webbynode::Commands::AddBackup.new
+    tie_dependencies(cmd)
+  }
+  
+  it "should allow user to specify a retention period, in days" do
+    io.should_receive(:app_name).and_return("app")
+    io.should_receive(:general_settings).any_number_of_times.and_return({ "aws_key" => "abc", "aws_secret" => "def" })
+    re.should_receive(:exec).with("config_app_backup").with(%Q(config_app_backup app "abc" "def" 10), true)
+
+    cmd = tie_dependencies(Webbynode::Commands::AddBackup.new("--retain=10"))
+    cmd.run
+  end
+  
+  it "should ask user's aws key and secret, if missing from ~/.weebynode" do
+    io.should_receive(:general_settings).any_number_of_times.and_return({})
+
+    io.should_receive(:add_general_setting).with("aws_key", "aws_key")
+    io.should_receive(:add_general_setting).with("aws_secret", "aws_secret")
+    
+    cmd.should_receive(:ask).with("AWS secret: ").and_return("aws_secret")
+    cmd.should_receive(:ask).with("AWS key: ").and_return("aws_key")
+    cmd.run
+  end
+  
+  it "should abort the configuration if user provides a blank AWS key" do
+    io.should_receive(:general_settings).any_number_of_times.and_return({})
+
+    io.should_receive(:add_general_setting).never
+    io.should_receive(:add_general_setting).never
+    
+    cmd.should_receive(:ask).with("AWS secret: ").never
+    cmd.should_receive(:ask).with("AWS key: ").and_return("")
+    cmd.run
+    
+    stdout.should =~ /Aborted./
+  end
+  
+  it "should not ask for key/secret if already present" do
+    io.should_receive(:general_settings).any_number_of_times.and_return({ "aws_key" => "abc", "aws_secret" => "def" })
+    
+    cmd.should_receive(:ask).with("AWS secret: ").never
+    cmd.should_receive(:ask).with("AWS key: ").never
+    cmd.run
+  end
+  
+  it "should execute the config_app_backup utility on the server" do
+    io.should_receive(:app_name).and_return("app_name")
+    io.should_receive(:general_settings).any_number_of_times.and_return({ "aws_key" => "awskey", "aws_secret" => "awsecret" })
+    re.should_receive(:exec).with("config_app_backup").with(%Q(config_app_backup app_name "awskey" "awsecret"), true)
+
+    cmd.run
+  end
+end

data/spec/webbynode/commands/add_key_spec.rb

@@ -0,0 +1,58 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Commands::AddKey do
+  let(:server) { double("server") }
+  
+  it "should have a constant pointing to the ssh key location" do
+    Webbynode::Commands::AddKey::LocalSshKey.should == "#{ENV['HOME']}/.ssh/id_rsa.pub"
+  end
+  
+  it "should be aliased to addkey" do
+    Webbynode::Commands.should_receive(:const_get).with("AddKey")
+    Webbynode::Command.for("addkey")
+  end
+  
+  context "when successful" do
+    it "should upload the local ssh key into the server" do
+      server.should_receive(:add_ssh_key).with(Webbynode::Commands::AddKey::LocalSshKey, nil)
+
+      cmd = Webbynode::Commands::AddKey.new
+      cmd.should_receive(:server).any_number_of_times.and_return(server)
+      cmd.execute
+    end
+
+    it "should create an ssh key with a provided passphrase" do
+      server.should_receive(:add_ssh_key).with(Webbynode::Commands::AddKey::LocalSshKey, "my_passphrase")
+
+      cmd = Webbynode::Commands::AddKey.new("--passphrase=my_passphrase")
+      cmd.should_receive(:server).any_number_of_times.and_return(server)
+      cmd.execute
+    end
+  end
+
+  context "when unsuccessful" do
+    let(:cmd) { Webbynode::Commands::AddKey.new }
+    let(:io)  { double("Io").as_null_object }  
+    
+    before(:each) do
+      cmd.should_receive(:io).any_number_of_times.and_return(io)
+    end
+    
+    it "should report an error if the ssh key could not be added due to invalid authentication" do
+      server.should_receive(:add_ssh_key).and_raise(Webbynode::InvalidAuthentication)
+
+      cmd.should_receive(:server).any_number_of_times.and_return(server)
+      io.should_receive(:log).with("Could not connect to webby: invalid authentication.", true)
+      cmd.execute
+    end
+
+    it "should report an error if the ssh key could not be added due to a permission error" do
+      server.should_receive(:add_ssh_key).and_raise(Webbynode::PermissionError)
+
+      cmd.should_receive(:server).any_number_of_times.and_return(server)
+      io.should_receive(:log).with("Could not create an SSH key: permission error.", true)
+      cmd.execute
+    end
+  end
+end

data/spec/webbynode/commands/alias_spec.rb

@@ -0,0 +1,213 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Commands::Alias do
+
+  let(:a) { Webbynode::Commands::Alias.new("add", "my_alias", "ls", "-la") }
+  let(:io) { double('io').as_null_object }
+
+  before(:each) do
+    a.should_receive(:io).any_number_of_times.and_return(io)
+    File.stub!(:read).with(Webbynode::Commands::Alias::FilePath).
+      and_return(File.join(File.dirname(__FILE__), '../../fixtures/aliases'))
+  end
+  
+  it "should have a constant pointing at the aliases file" do
+    Webbynode::Commands::Alias::FilePath.should eql(".webbynode/aliases")
+  end
+  
+  describe "params" do
+    it "should parse the add commands" do
+      a = Webbynode::Commands::Alias.new("add", "my_alias", "ls", "-la")
+      a.stub!(:send).with("add")
+      a.execute
+      a.action.should eql("add")
+      a.alias.should eql("my_alias")
+      a.command.should eql("ls -la")
+    end
+    
+    it "should parse the remove commands" do
+      a = Webbynode::Commands::Alias.new("remove", "my_alias")
+      a.stub!(:send).with("remove")
+      a.execute
+      a.action.should eql("remove")
+      a.alias.should eql("my_alias")
+      a.command.should be_blank
+    end
+  end
+  
+  describe "#exists?" do
+    it "should determine whether the specified alias already exists" do
+      a.exists?("my_alias").should be_false
+    end
+    
+    it "should determine whether the specified alias already exists" do
+      a.session_aliases << "[my_alias] rake db:migrate"
+      a.exists?("my_alias").should be_true
+    end
+  end
+  
+  describe "#extract_command" do
+    it "should extract the command from the session_aliases based on the given alias if it exists" do
+      a = Webbynode::Commands::Alias.new
+      a.stub!(:read_aliases_file)
+      a.session_aliases << "[my_alias] rake db:migrate"
+      a.extract_command('my_alias').should eql("rake db:migrate")
+    end
+    
+    it "should return false because the requested alias does not exist" do
+      a = Webbynode::Commands::Alias.new
+      a.stub!(:read_aliases_file)
+      a.extract_command('my_alias').should be_false
+    end
+  end
+  
+  describe "aliases file availability" do
+    context "when the aliases file is not present" do
+      it "should create it" do
+        io.should_receive(:file_exists?).with(Webbynode::Commands::Alias::FilePath).and_return(false)
+        io.should_receive(:exec).with("touch #{Webbynode::Commands::Alias::FilePath}")
+        a.ensure_aliases_file_exists
+      end
+    end
+    
+    context "when the aliases file is present" do
+      it "should not create it, nor overwrite it" do
+        io.should_receive(:file_exists?).with(Webbynode::Commands::Alias::FilePath).and_return(true)
+        io.should_not_receive(:exec).with("touch #{Webbynode::Commands::Alias::FilePath}")
+        a.ensure_aliases_file_exists
+      end
+    end
+  end
+  
+  describe "reading out the aliases from the file" do
+    it "should read out each line that has an alias" do
+      a.should_receive(:read_aliases_file)
+      a.execute
+    end
+  end
+  
+  describe "aliases file interaction" do
+    context "when writing to the file" do
+      it "should invoke the add method" do
+        a.should_receive(:send).with('add')
+        a.execute
+      end
+      
+      it "should append the new alias to the session_aliases" do
+        a.should_receive(:append_alias)
+        a.execute
+      end
+      
+      it "should open the file in 'write mode' to write all aliases from session_aliases to it" do
+        io.should_receive(:open_file).with(Webbynode::Commands::Alias::FilePath, "w")
+        a.execute
+      end
+      
+      it "should not add the alias to session_aliases if the command is blank" do
+        a = Webbynode::Commands::Alias.new("add", "my_alias")
+        a.should_receive(:io).any_number_of_times.and_return(io)
+        io.should_receive(:log).with("You must provide a remote command for the alias.", true)
+        a.execute
+        a.session_aliases.size.should eql(0)
+      end
+      
+      it "should not add the alias if it already exists" do
+        a = Webbynode::Commands::Alias.new("add", "my_alias", "custom command")
+        a.should_receive(:io).any_number_of_times.and_return(io)
+        a.stub!(:write_aliases)
+        a.stub!(:read_aliases_file)
+        a.session_aliases << "[my_alias] foo"
+        a.session_aliases << "[mah_alias] bar"
+        io.should_receive(:log).with("You already have an alias named [my_alias].", true)
+        a.execute
+        a.should have(2).session_aliases
+      end
+      
+      it "should not add the alias to session_aliases if the command is blank" do
+        a = Webbynode::Commands::Alias.new("add", "my_alias")
+        a.stub!(:write_aliases)
+        a.execute
+        a.session_aliases.size.should eql(0)
+      end
+      
+      it "should display the current list of aliases after adding the new one" do
+        a.should_receive(:show_aliases)
+        a.execute
+      end
+    end
+    
+    context "when removing from the file" do
+      before(:each) do
+        a = Webbynode::Commands::Alias.new("remove", "my_alias")
+        a.should_receive(:io).any_number_of_times.and_return(io)
+      end
+      
+      it "should invoke the remove method" do
+        a.should_receive(:send).with('remove')
+        a.execute
+      end
+      
+      it "should remove the alias if it exists" do
+        a.should_receive(:remove_alias)
+        a.execute
+      end
+      
+      it "should remove the specified alias from the array of aliases to write" do
+        a.stub!(:read_aliases_file)
+        3.times { |n| a.session_aliases << "[alias_#{n}] my_custom_alias_#{n}" }
+        a.should have(3).session_aliases
+        a.session_aliases << "[my_alias] what a nice alias"
+        a.should have(4).session_aliases
+        a.session_aliases.should include("[my_alias] what a nice alias")
+        a.execute
+        a.session_aliases.should_not include("[my_alias] what a nice alias")
+        a.should have(3).session_aliases
+      end
+      
+      it "should write to the aliases file to apply the changes" do
+        a.should_receive(:write_aliases)
+        a.execute
+      end
+      
+      it "should display the current list of aliases after removing the old one" do
+        a.should_receive(:show_aliases)
+        a.execute
+      end
+    end
+    
+    context "reading from the file" do
+      before(:each) do
+        a = Webbynode::Commands::Alias.new("show")
+        a.should_receive(:io).any_number_of_times.and_return(io)
+      end
+      
+      it "should invoke the show method" do
+        a.should_receive(:send).with("show")
+        a.execute
+      end
+      
+      it "should show the aliases" do
+        a.should_receive(:show_aliases)
+        a.execute
+      end
+      
+      it "should display all the aliases to the user if there are any" do
+        a.stub!(:read_aliases_file)
+        a.session_aliases << "[my_alias] rake db:migrate"
+        io.should_receive(:log).with("These are your current aliases..")
+        io.should_receive(:log).with("[my_alias] rake db:migrate")
+        a.session_aliases.should_receive(:any?).and_return(true)
+        a.execute
+      end
+      
+      it "it should not display any aliases since there are none. Will display a friendly message instead." do
+        a.stub!(:read_aliases_file)
+        a.session_aliases.should_receive(:any?).and_return(false)
+        io.should_receive(:log).with("You have not yet set up any aliases.", true)
+        a.execute
+      end
+    end
+  end
+  
+end

data/spec/webbynode/commands/change_dns_spec.rb

@@ -0,0 +1,51 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'spec_helper')
+
+describe Webbynode::Commands::ChangeDns do
+  let(:git) { double("git").as_null_object }
+  let(:io)  { double("io").as_null_object }
+  let(:api) { double("api").as_null_object }
+  let(:cmd) { Webbynode::Commands::ChangeDns.new("the.newdns.com") }
+  
+
+  before(:each) do
+    FakeWeb.clean_registry
+    cmd.should_receive(:io).any_number_of_times.and_return(io)
+    cmd.should_receive(:git).any_number_of_times.and_return(git)
+    cmd.should_receive(:api).any_number_of_times.and_return(api)
+    
+  end
+
+  it "should change pushand" do
+    io.should_receive(:app_name).and_return("myapp")
+    io.should_receive(:create_file).with(".pushand", "#! /bin/bash\nphd $0 myapp the.newdns.com\n", true)
+    git.should_receive(:parse_remote_ip).and_return("1.2.3.4")
+    api.should_receive(:create_record).with("the.newdns.com", "1.2.3.4")
+    
+    cmd.run
+  end
+  
+  it "should give an error message if there are git changes pending" do
+    git.should_receive(:clean?).and_return(false)
+    
+    cmd.run
+    stdout.should =~ /Cannot change DNS because you have pending changes. Do a git commit or add changes to .gitignore./
+  end
+
+  context "when committing the DNS change" do
+    it "should perform a commit of .pushand" do
+      io.should_receive(:file_exists?).with(".webbynode/settings").and_return(false)
+      git.should_receive(:add).with(".pushand")
+      git.should_receive(:commit).with("Changed DNS to \"the.newdns.com\"")
+      cmd.run
+    end
+
+    it "should perform a commit of .pushand and .webbynode/settings if the later exists" do
+      io.should_receive(:file_exists?).with(".webbynode/settings").and_return(true)
+      git.should_receive(:add).with(".pushand")
+      git.should_receive(:add).with(".webbynode/settings")
+      git.should_receive(:commit).with("Changed DNS to \"the.newdns.com\"")
+      cmd.run
+    end
+  end
+end