webbynode 0.1.2 → 0.2.0

data/spec/webbynode/git_spec.rb

@@ -0,0 +1,310 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+describe Webbynode::Git do
+  def should_raise_when_response(exception, command, response, &blk)
+    io_handler = mock("io")
+    io_handler.should_receive(:exec).with(command).and_return(response)
+
+    git = Webbynode::Git.new
+    git.should_receive(:io).and_return(io_handler)
+    lambda { yield git }.should raise_error(exception)
+  end
+
+  def should_raise(exception, command, &blk)
+    should_raise_when_response exception, command, 
+      "fatal: remote webbynode already exists.", &blk
+  end
+
+  def should_raise_giterror(command, &blk)
+    should_raise_when_response Webbynode::GitError, command, 
+      "/private/tmp/other/.git: Permission denied", &blk
+  end
+
+  def should_raise_notgitrepo(command, &blk)
+    should_raise_when_response Webbynode::GitNotRepoError, command, 
+      "fatal: Not a git repository (or any of the parent directories): .git", &blk
+  end
+  
+  it "should have an io instance" do
+    Webbynode::Git.new.io.class.should == Webbynode::Io
+  end
+  
+  describe "#present?" do
+    it "should be true if folder .git exists" do
+      io_handler = mock("io")
+      io_handler.should_receive(:directory?).with(".git").and_return(true)
+    
+      git = Webbynode::Git.new
+      git.should_receive(:io).and_return(io_handler)
+      git.should be_present
+    end
+
+    it "should be false if folder .git doesn't exist" do
+      io_handler = mock("io")
+      io_handler.should_receive(:directory?).with(".git").and_return(false)
+
+      git = Webbynode::Git.new
+      git.should_receive(:io).and_return(io_handler)
+      git.should_not be_present
+    end
+  end
+  
+  describe "#clean?" do
+    context "when git repo is clean" do
+      it "should return true" do
+        io_handler = mock("io")
+        io_handler.should_receive(:exec).with("git status").and_return(read_fixture('git/status/clean'))
+
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        git.should be_clean
+      end
+    end
+
+    context "when git repo is dirty" do
+      it "should return false" do
+        io_handler = mock("io")
+        io_handler.should_receive(:exec).with("git status").and_return(read_fixture('git/status/dirty'))
+
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        git.should_not be_clean
+      end
+    end
+  end
+  
+  describe "#add_git_init" do
+    context "when sucessful" do
+      it "should create .gitignore from the template" do
+        io = double("io")
+        io.should_receive(:create_from_template).with(".gitignore", "gitignore")
+        
+        git = Webbynode::Git.new
+        git.stub(:io).and_return(io)
+        git.add_git_ignore
+      end
+    end
+  end
+  
+  describe "#init" do
+    context "when successful" do
+      it "should return true" do
+        io_handler = mock("io")
+        io_handler.should_receive(:exec).with("git init").and_return("Initialized empty Git repository in /Users/fcoury/tmp/.git/")
+
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        git.init.should be_true
+      end
+    end
+    
+    context "when unsuccessfull" do
+      it "should raise exception if not a git repo" do
+        should_raise_notgitrepo("git init") { |git| git.init }
+      end
+
+      it "should raise a generic Git error if there's another error creating the repo" do
+        should_raise_giterror("git init") { |git| git.init }
+      end
+    end
+  end
+  
+  describe "#add_remote" do
+    context "when successfull" do
+      it "should create a new remote" do
+        io_handler = mock("io")
+        io_handler.should_receive(:exec).with("git remote add webbynode git@1.2.3.4:the_repo").and_return("")
+
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        git.add_remote("webbynode", "1.2.3.4", "the_repo").should be_true
+      end
+    end
+    
+    context "when unsuccessfull" do
+      it "should raise exception if not a git repo" do
+        should_raise_notgitrepo("git remote add other git@5.6.7.8:a_repo") { |git| git.add_remote("other", "5.6.7.8", "a_repo") }
+      end
+    
+      it "should return raise exception if the remote already exists" do
+        should_raise(Webbynode::GitRemoteAlreadyExistsError, "git remote add other git@5.6.7.8:a_repo") { |git| 
+          git.add_remote("other", "5.6.7.8", "a_repo")
+        }
+      end  
+      
+      it "should raise a generic Git error when another error occurs" do
+        should_raise_giterror("git remote add other git@5.6.7.8:a_repo") { |git| git.add_remote("other", "5.6.7.8", "a_repo") }
+      end
+    end
+  end
+  
+  describe "#add" do
+    context "when successfull" do
+      it "should add objects to git" do
+        io_handler = mock("io")
+        io_handler.should_receive(:exec).with('git add the_file')
+      
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        git.add("the_file")
+      end
+
+      it "should handle adding multiple files" do
+        io_handler = mock("io")
+        io_handler.should_receive(:exec).with('git add one_file/ other_file/')
+      
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        git.add("one_file/ other_file/")
+      end
+    end
+    
+    context "when unsuccessfull" do
+      it "should raise exception if not a git repo" do
+        should_raise_notgitrepo("git add .") { |git| git.add(".") }
+      end
+
+      it "should raise a generic Git error when another error occurs" do
+        should_raise_giterror("git add something") { |git| git.add("something") }
+      end
+    end
+  end
+
+  describe "#commit" do
+    context "when successfull" do
+      it "should add objects to git" do
+        io_handler = mock("io")
+        io_handler.should_receive(:exec).with('git commit -m "Commit comment"').and_return("[master (root-commit) 8f590c7] Commit comment
+         43 files changed, 8445 insertions(+), 0 deletions(-)")
+
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        git.commit("Commit comment")
+      end
+      
+      it "should escape double quotes" do
+        io_handler = mock("io")
+        io_handler.should_receive(:exec).with('git commit -m "Commiting \"the comment\""').and_return("[master (root-commit) 8f590c7] Commiting \"the comment\"
+         43 files changed, 8445 insertions(+), 0 deletions(-)")
+
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        git.commit('Commiting "the comment"')
+      end
+    end
+    
+    context "when unsuccessfull" do
+      it "should raise exception if not a git repo" do
+        should_raise_giterror("git add .") { |git| git.add(".") }
+      end
+    end
+  end
+  
+  describe "#remote_webbynode?" do
+    context "when successful" do
+      it "should check if webbynode has been initialized inside of an existing git repository" do
+        io_handler = mock("Io")
+        io_handler.as_null_object
+      
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        io_handler.should_receive(:exec).with('git remote').and_return('origin\nwebbynode')
+        git.remote_webbynode?.should be_true
+      end
+    end
+    
+    context "when unsuccessful" do
+      it "should not contain remote webbynode" do
+        io_handler = mock("Io")
+        io_handler.as_null_object
+
+        git = Webbynode::Git.new
+        git.should_receive(:io).and_return(io_handler)
+        io_handler.should_receive(:exec).with('git remote').and_return('origin')
+        git.remote_webbynode?.should be_false
+      end
+    end
+  end
+  
+  describe "#parse_config" do
+    context "when successful" do
+      it "git should be present" do
+        io_handler = mock("Io")
+        io_handler.as_null_object
+        
+        git = Webbynode::Git.new
+        git.should_receive(:io).any_number_of_times.and_return(io_handler)
+        git.stub!(:remote_webbynode?).and_return(true)
+        git.should_receive(:present?).and_return(true)
+        File.should_receive(:open).exactly(:once).with(".git/config").and_return(read_fixture('git/config/config'))
+        git.parse_config
+      end
+      
+      it "should open the git configuration file and parse it" do
+        io_handler = mock("io")
+        io_handler.as_null_object
+        
+        File.should_receive(:open).exactly(:once).with(".git/config").and_return(read_fixture('git/config/config'))
+        git = Webbynode::Git.new
+        git.stub!(:remote_webbynode?).and_return(true)
+        git.should_receive(:io).any_number_of_times.and_return(io_handler)
+        git.parse_config
+      end
+    
+      it "should open the git configuration file and parse it only once" do
+        io_handler = mock("io")
+        io_handler.as_null_object
+
+        File.should_receive(:open).exactly(:once).with(".git/config").and_return(read_fixture('git/config/config'))
+        git = Webbynode::Git.new
+        git.stub!(:remote_webbynode?).and_return(true)
+        git.should_receive(:io).any_number_of_times.and_return(io_handler)
+        5.times {git.parse_config}
+      end
+    end
+    
+    context "when unsuccessful" do
+      it "should raise an exception if the git repository does not exist." do
+        git = Webbynode::Git.new
+        git.should_receive(:present?).at_least(:once).and_return(false)
+        git.stub!(:remote_webbynode?).and_return(true)
+        File.should_not_receive(:open)
+        lambda {git.parse_config}.should raise_error(Webbynode::GitNotRepoError, "Git repository does not exist.")
+      end
+      
+      it "should raise an exception if the git repository does exist, but does not have the git remote for webbynode" do
+        git = Webbynode::Git.new
+        git.should_receive(:present?).at_least(:once).and_return(true)
+        git.stub!(:remote_webbynode?).and_return(false)
+        File.should_not_receive(:open)
+        lambda {git.parse_config}.should raise_error(Webbynode::GitRemoteDoesNotExistError, "Webbynode has not been initialized.")
+      end
+    end
+  end
+
+
+  describe "#parse_remote_ip" do
+    context "when successful" do
+      it "should parse the configuration file" do
+        git = Webbynode::Git.new
+        git.should_receive(:parse_config)
+        git.parse_remote_ip
+      end
+    
+      it "should extract the remote ip from the parsed configuration file" do
+        io_handler = mock("io")
+        io_handler.as_null_object
+      
+        git = Webbynode::Git.new
+        git.stub!(:remote_webbynode?).and_return(true)
+        git.should_receive(:io).and_return(io_handler)
+        File.should_receive(:open).exactly(:once).with(".git/config").and_return(read_fixture('git/config/config'))
+        git.parse_remote_ip
+        git.config.should_not be_empty
+        git.remote_ip.should eql('1.2.3.4')
+      end
+    end
+  end
+
+end

data/spec/webbynode/io_spec.rb

@@ -0,0 +1,198 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+describe Webbynode::Io do
+  describe "#app_name" do
+    context "when successful" do
+      it "should return the current folder" do
+        Dir.should_receive(:pwd).and_return("/some/deep/folder/where/you/find/app_name")
+        Webbynode::Io.new.app_name.should == "app_name"
+      end
+
+      it "should transform dots and spaces into underscores" do
+        Dir.should_receive(:pwd).and_return("/some/deep/folder/where/you/find/my.app here")
+        Webbynode::Io.new.app_name.should == "my_app_here"
+      end
+    end
+  end
+  
+  describe '#add_setting' do
+    let(:io) { Webbynode::Io.new }
+
+    it "should add a key to the property file .webbynode/settings" do
+      props = mock("Hash")
+      props.should_receive(:[]=).with("engine", "php")
+      props.should_receive(:save)
+      
+      io.should_receive(:properties).with(".webbynode/settings").and_return(props)
+      io.add_setting("engine", "php")
+    end
+  end
+  
+  describe '#remove_setting' do
+    let(:io) { Webbynode::Io.new }
+
+    it "should add a key to the property file .webbynode/settings" do
+      props = mock("Hash")
+      props.should_receive(:remove).with("engine")
+      props.should_receive(:save)
+      
+      io.should_receive(:properties).with(".webbynode/settings").and_return(props)
+      io.remove_setting("engine")
+    end
+  end
+  
+  describe '#create_local_key' do
+    describe "when key file missing" do
+      before(:each) do
+        File.should_receive(:exists?).with(Webbynode::Commands::AddKey::LocalSshKey).and_return(false)
+        @io = Webbynode::Io.new
+      end
+
+      context "with no passphrase" do
+        it "should create the key with an empty passphrase" do
+          @io.should_receive(:exec).with("ssh-keygen -t rsa -N \"\" -f #{Webbynode::Commands::AddKey::LocalSshKey}").and_return("")
+          @io.create_local_key
+        end
+      end
+      
+      context "with a passphrase" do
+        it "should create the key with the provided passphrase" do
+          @io.should_receive(:exec).with("ssh-keygen -t rsa -N \"passphrase\" -f #{Webbynode::Commands::AddKey::LocalSshKey}").and_return("")
+          @io.create_local_key("passphrase")
+        end
+      end
+    end
+    
+    describe "when key already exists" do
+      before(:each) do
+        File.should_receive(:exists?).with(Webbynode::Commands::AddKey::LocalSshKey).and_return(true)
+        @io = Webbynode::Io.new
+      end
+
+      it "should just skip the creation" do
+        @io.should_receive(:exec).never
+        @io.create_local_key
+      end
+    end
+  end
+  
+  describe '#file_exists?' do
+    before(:each) do; @io = Webbynode::Io.new; end
+    
+    it "should return true if file exists" do
+      File.should_receive(:exists?).with("file").and_return(true)
+      @io.file_exists?("file").should be_true
+    end
+    
+    it "should return false if file doesn't exist" do
+      File.should_receive(:exists?).with("file").and_return(false)
+      @io.file_exists?("file").should be_false
+    end
+  end
+    
+  describe '#templates_path' do
+    it "should return the contents of TemplatesPath" do
+      io = Webbynode::Io.new
+      io.templates_path.should == Webbynode::Io::TemplatesPath
+    end
+  end
+  
+  describe '#create_from_template' do
+    it "should read the template and write a new file with its contents" do
+      io = Webbynode::Io.new
+      io.should_receive(:read_from_template).with("template_file").and_return("template_file_contents")
+      io.should_receive(:create_file).with("output_file", "template_file_contents")
+      io.create_from_template("output_file", "template_file")
+    end
+  end
+  
+  describe '#read_from_template' do
+    it "should read a file from the templates path" do
+      io = Webbynode::Io.new
+      io.should_receive(:templates_path).and_return("/templates")
+      io.should_receive(:read_file).with("/templates/template_file").and_return("template_contents")
+      io.read_from_template("template_file").should == "template_contents"
+    end
+  end
+  
+  describe '#create_file' do
+    it "should create a file with specified contents" do
+      file = double("File")
+      File.should_receive(:open).with("file_to_write", "w").and_yield(file)
+      file.should_receive(:write).with("file_contents")
+
+      io = Webbynode::Io.new
+      io.create_file("file_to_write", "file_contents")
+    end
+    
+    it "should accept an optional executable parameter" do
+      file = double("File")
+      File.should_receive(:open).with("file_to_write", "w").and_yield(file)
+      file.should_receive(:write).with("file_contents")
+      
+      FileUtils.should_receive(:chmod).with(0755, "file_to_write")
+
+      io = Webbynode::Io.new
+      io.create_file("file_to_write", "file_contents", true)
+    end
+  end
+  
+  describe "#exec" do
+    context "when successful" do
+      it "should execute the command and retrieve the output" do
+        io = Webbynode::Io.new
+        io.should_receive(:`).with("ls -la 2>&1").and_return("output for ls -la")
+        io.exec("ls -la").should == "output for ls -la"
+      end
+    end
+  end
+  
+  describe "#read_file" do
+    context "when successful" do
+      it "should return file contents" do
+        io = Webbynode::Io.new
+        File.should_receive(:read).with("filename").and_return("file contents")
+        io.read_file("filename").should == "file contents"
+      end
+    end
+  end
+  
+  describe "#directory?" do
+    context "when successful" do
+      it "should return true when item is a directory" do
+        File.should_receive(:directory?).with("dir").and_return(true)
+
+        io = Webbynode::Io.new
+        io.directory?("dir").should == true
+      end
+
+      it "should return false when item is not a directory" do
+        File.should_receive(:directory?).with("dir").and_return(false)
+
+        io = Webbynode::Io.new
+        io.directory?("dir").should == false
+      end
+    end
+  end
+  
+  describe "#open_file" do
+    it "should open the file" do
+      io = Webbynode::Io.new
+      File.should_receive(:open).with("filename", anything).and_return("file contents")
+      io.open_file("filename", anything).should eql("file contents")
+    end
+  end
+  
+  describe "#read_config" do
+    it "should parse value = key pairs" do
+      io = Webbynode::Io.new
+      io.should_receive(:read_file).with("config").and_return("a = b\nc = d\nother = rest")
+      
+      cfg = io.read_config("config")
+      cfg[:a].should == "b"
+      cfg[:c].should == "d"
+      cfg[:other].should == "rest"
+    end
+  end
+end

data/spec/webbynode/option_spec.rb

@@ -0,0 +1,48 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+describe Webbynode::Option do
+  it "should require the name" do
+    lambda { Webbynode::Option.new }.should raise_error
+  end
+
+  it "should parse the name" do
+    Webbynode::Option.new(:param1).name.should == :param1
+    Webbynode::Option.new(:param2).name.should == :param2
+  end
+  
+  it "should parse the type, if given" do
+    Webbynode::Option.new(:param1, Integer).kind.should == Integer
+  end
+  
+  it "should assume String for the type, if none given" do
+    Webbynode::Option.new(:param1).kind.should == String
+    Webbynode::Option.new(:param1, "My description").kind.should == String
+  end
+  
+  it "should parse the description" do
+    Webbynode::Option.new(:param1, "My description").desc.should == "My description"
+    Webbynode::Option.new(:param1, String, "My description").desc.should == "My description"
+  end
+  
+  it "should parse the options" do
+    Webbynode::Option.new(:param1, "My description", :amazing => true).options[:amazing].should be_true
+  end
+  
+  describe "#to_s" do
+    it "should parse use the name and the value option" do
+      Webbynode::Option.new(:param1, "My param", :take => :value).to_s.should == "--param1=value"
+      Webbynode::Option.new(:param1, "My param").to_s.should == "--param1"
+    end
+  end
+  
+  describe "validating" do
+    it "should validate against values if :in passed" do
+      opt = Webbynode::Option.new(:option1, "My option", :validate => { :in => ['a', 'b'] })
+      opt.value = 'c'
+      opt.should_not be_valid
+      opt.errors.should be_include("Invalid value 'c' for option 'option1'. It should be one of 'a' or 'b'.")
+      lambda { opt.validate! }.should raise_error(Webbynode::Command::InvalidCommand, "Invalid value 'c' for option 'option1'. It should be one of 'a' or 'b'.")
+    end
+  end
+end

data/spec/webbynode/parameter_spec.rb

@@ -0,0 +1,70 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+describe Webbynode::Parameter do
+  it "should require the name" do
+    lambda { Webbynode::Parameter.new }.should raise_error
+  end
+  
+  it "should allow setting a value" do
+    param = Webbynode::Parameter.new(:param1)
+    param.value = "hello"
+    param.value.should == "hello"
+  end
+
+  it "should parse the name" do
+    Webbynode::Parameter.new(:param1).name.should == :param1
+    Webbynode::Parameter.new(:param2).name.should == :param2
+  end
+  
+  it "should parse the type, if given" do
+    Webbynode::Parameter.new(:param1, Integer).kind.should == Integer
+  end
+  
+  it "should assume String for the type, if none given" do
+    Webbynode::Parameter.new(:param1).kind.should == String
+    Webbynode::Parameter.new(:param1, "My description").kind.should == String
+  end
+  
+  it "should parse the description" do
+    Webbynode::Parameter.new(:param1, "My description").desc.should == "My description"
+    Webbynode::Parameter.new(:param1, String, "My description", :required => true).desc.should == "My description"
+  end
+  
+  it "should parse the options" do
+    Webbynode::Parameter.new(:param1, "My description", :required => true).options[:required].should be_true
+  end
+  
+  it "should be required by default" do
+    Webbynode::Parameter.new(:param1).should be_required
+  end
+  
+  describe "#required?" do
+    it "should be true if no param's :required is given" do
+      Webbynode::Parameter.new(:param1, "My description").options[:required].should be_true
+      Webbynode::Parameter.new(:param1, "My description").should be_required
+    end      
+   
+    it "should be true if param's :required is true" do
+      Webbynode::Parameter.new(:param1, "My description", :required => true).options[:required].should be_true
+      Webbynode::Parameter.new(:param1, "My description", :required => true).should be_required
+    end      
+   
+    it "should be false if param's :required is false" do
+      Webbynode::Parameter.new(:param1, "My description", :required => false).options[:required].should be_false
+      Webbynode::Parameter.new(:param1, "My description", :required => false).should_not be_required
+    end
+  end
+  
+  describe "#to_s" do
+    it "should render as the parameter name if required" do
+      Webbynode::Parameter.new(:param1).to_s.should == "param1"
+    end
+
+    it "should render on square brackets if optional" do
+      par = Webbynode::Parameter.new(:param2, "some description", :required => false)
+      par.should_not be_required
+      par.to_s.should == "[param2]"
+    end
+  end
+end

data/spec/webbynode/push_and_spec.rb

@@ -0,0 +1,28 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+describe Webbynode::PushAnd do
+  before(:each) do
+    @io = mock(:io)
+    @pushand = Webbynode::PushAnd.new
+    @pushand.should_receive(:io).any_number_of_times.and_return(@io)
+  end
+  
+  it "should have an Io instance" do
+    Webbynode::PushAnd.new.io.class.should == Webbynode::Io
+  end
+
+  describe "#present?" do
+    it "should return true when .pushand file is present" do
+      @io.should_receive(:file_exists?).with(".pushand").and_return(true)
+      @pushand.present?.should == true
+    end
+  end
+  
+  describe "parse_remote_app_name" do
+    it "should parse the .pushand file for the app name" do
+      @io.should_receive(:read_file).with(".pushand").and_return("phd $0 app_name dnsentry")
+      @pushand.parse_remote_app_name.should == "app_name"
+    end
+  end
+end

data/spec/webbynode/remote_executor_spec.rb

@@ -0,0 +1,25 @@
+# Load Spec Helper
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'spec_helper')
+
+describe Webbynode::RemoteExecutor do
+  before(:each) do
+    @ssh = mock("ssh")
+    
+    @re = Webbynode::RemoteExecutor.new("2.2.2.2")
+    @re.should_receive(:ssh).any_number_of_times.and_return(@ssh)
+  end
+  
+  describe "#exec" do
+    it "should execute the raw command on the server" do
+      @ssh.should_receive(:execute).with("the same string I pass", false)
+      @re.exec "the same string I pass"
+    end
+  end
+  
+  describe "#create_folder" do
+    it "should create the folder on the server" do
+      @ssh.should_receive(:execute).with("mkdir -p /var/new_folder")
+      @re.create_folder "/var/new_folder"
+    end
+  end
+end