machines 0.5.1

data/spec/lib/machines/commandline_spec.rb

@@ -0,0 +1,299 @@
+require 'spec_helper'
+
+describe Machines::Commandline do
+  include Machines::Core
+  include Machines::Commandline
+  include Machines::Questions
+
+  before(:each) do
+    $conf.log_only = false
+    File.open('config.yml', 'w') { |f| f.puts "timezone: GB" }
+    FileUtils.mkdir_p 'log'
+  end
+
+  describe 'build' do
+    before(:each) do
+      stubs(:init)
+      FileUtils.touch('Machinesfile')
+      $conf.machine = AppConf.new
+      $conf.machine.address = 'target'
+      $conf.machine.user = 'username'
+      $conf.password = 'userpass'
+      Net::SCP.stubs(:new)
+      @ssh_stub = stub('Net::SSH', :close => nil, :exec! => nil)
+      Net::SSH.stubs(:start).returns @ssh_stub
+    end
+
+    it 'sets machine_name' do
+      build ['machine']
+      $conf.machine_name.must_equal 'machine'
+    end
+
+    it 'starts an SCP session using password authentication' do
+      Net::SSH.expects(:start).with('target', 'username', :paranoid => false, :password => 'userpass').returns @ssh_stub
+      build []
+    end
+
+    it 'starts an SCP session using key based authentication' do
+      $conf.machine.cloud = AppConf.new
+      $conf.machine.cloud.private_key_path = 'path/to/private_key'
+      $conf.machine.cloud.username = 'ubuntu'
+      Net::SSH.expects(:start).with('target', 'ubuntu', :paranoid => false, :keys => ['path/to/private_key']).returns @ssh_stub
+
+      build []
+    end
+
+    it 'runs each command' do
+      mock_command = mock 'Machines::Command'
+      $conf.commands = [mock_command]
+
+      mock_command.expects(:run)
+
+      build []
+    end
+
+    it 'flushes log file after running command' do
+      $conf.log_only = false
+      command_stub = stub('Machines::Command', :run => nil)
+      $conf.commands = [command_stub]
+
+      Machines::Command.file.expects(:flush)
+      build []
+    end
+
+    it 'replaces commands with the single task when supplied' do
+      command_will_run = Machines::Command.new '', ''
+      command_wont_run = Machines::Command.new '', ''
+      $conf.tasks = { :task => {:block => Proc.new { run command_will_run }} }
+
+      build ['machine', 'task']
+
+      $conf.commands.must_equal [command_will_run]
+    end
+
+    it 'logs instead of SSHing and running commands' do
+      Net::SCP.expects(:start).never
+      $conf.commands = [mock('Machines::Command')]
+      $conf.commands.first.expects(:run)
+      $conf.log_only = true
+      build []
+    end
+
+    describe 'interrupts' do
+      before(:each) do
+        mock_command = mock 'Machines::Command'
+        $conf.commands = [mock_command]
+
+        mock_command.stubs(:run)
+        $exit_requested = false
+      end
+
+      it 'handles CTRL+C and calls handler' do
+        expects(:prepare_to_exit)
+        Kernel.expects(:trap).with('INT').yields
+        build []
+      end
+
+
+      it 'sets exit flag and displays message' do
+        prepare_to_exit
+        $exit_requested.must_equal true
+        $console.next.must_equal colored("\nEXITING after current command completes...\n", :warning)
+      end
+
+      it 'second request to exit exits immediately' do
+        $exit_requested = true
+        expects(:exit)
+        prepare_to_exit
+      end
+
+      it 'exits when exit requested' do
+        $exit_requested = true
+        expects(:exit)
+
+        build []
+      end
+    end
+  end
+
+  describe 'dryrun' do
+    it 'asks build to only log commands' do
+      options = []
+      expects(:build).with options
+      dryrun options
+      $conf.log_only.must_equal true
+    end
+  end
+
+  describe 'execute' do
+    it 'calls specified action' do
+      Machines::Help.new.actions.reject{|a| a == 'new'}.each do |action|
+        expects action
+        execute [action]
+      end
+    end
+
+    it 'calls generate with folder' do
+      expects(:generate).with(['dir'])
+      execute ['new', 'dir']
+    end
+
+    it 'calls generate without folder' do
+      expects(:generate).with([])
+      execute ['new']
+    end
+
+    it 'calls help when no matching command' do
+      lambda { execute ['anything'] }.must_output Machines::Help.new.syntax
+    end
+  end
+
+  describe 'generate' do
+    it 'copies the template within ./' do
+      expects(:ask).with("Overwrite './' (y/n)? ").returns 'y'
+      FileUtils.expects(:cp_r).with("#{$conf.application_dir}/template/.", './')
+      FileUtils.expects(:mkdir_p).with('./packages')
+      generate []
+    end
+
+    it 'copies the template within dir' do
+      FileUtils.expects(:cp_r).with("#{$conf.application_dir}/template/.", 'dir')
+      FileUtils.expects(:mkdir_p).with(File.join('dir', 'packages'))
+      expects(:say).with('Project created at dir/')
+      generate ['dir']
+    end
+
+    describe 'when folder exists' do
+      before(:each) do
+        FileUtils.mkdir_p('dir')
+      end
+
+      it 'is overwritten after user confirmation' do
+        expects(:ask).with("Overwrite 'dir' (y/n)? ").returns 'y'
+        FileUtils.expects(:cp_r).with("#{$conf.application_dir}/template/.", 'dir')
+        FileUtils.expects(:mkdir_p).with(File.join('dir', 'packages'))
+        generate ['dir']
+      end
+
+      it 'generation is aborted at user request' do
+        expects(:ask).with("Overwrite 'dir' (y/n)? ").returns 'n'
+        FileUtils.expects(:cp_r).never
+        FileUtils.expects(:mkdir_p).never
+        generate ['dir']
+      end
+    end
+  end
+
+  describe 'htpasswd' do
+    it 'htpasswd is generated and saved' do
+      $conf.webserver = 'server'
+      $input.string = "user\npass\npass\n"
+      htpasswd nil
+      File.read('server/conf/htpasswd').must_match /user:.{13}/
+    end
+  end
+
+  describe 'init' do
+    it 'initializes some $conf settings and loads configs' do
+      Machines::Command.file = nil
+      Machines::Command.console = nil
+      Machines::Command.debug = nil
+      init
+      $conf.passwords.must_equal []
+      $conf.commands.must_equal []
+      $conf.tasks.must_equal({})
+      $conf.timezone.must_equal 'GB'
+      File.exists?('log/output.log').must_equal true
+      Machines::Command.file.must_be_instance_of Machines::Logger
+      Machines::Command.console.must_be_instance_of Machines::Logger
+      Machines::Command.debug.must_be_instance_of Machines::Logger
+    end
+  end
+
+  describe 'load_machinesfile' do
+    it 'raises LoadError with custom message when no Machinesfile' do
+      File.expects(:read).with("Machinesfile").raises LoadError.new('Machinesfile not found')
+
+      begin
+        load_machinesfile
+      rescue LoadError => e
+        e.message.must_equal 'Machinesfile does not exist. Use `machines new <DIR>` to create a template.'
+      end
+    end
+
+    it 'raises normal LoadError on other files' do
+      File.expects(:read).with("Machinesfile").raises LoadError
+
+      begin
+        load_machinesfile
+      rescue LoadError => e
+        e.message.must_equal 'LoadError'
+      end
+    end
+  end
+
+  describe 'override' do
+    before(:each) do
+      FileUtils.mkdir_p File.join($conf.application_dir, 'packages')
+      FileUtils.mkdir_p 'packages'
+      FileUtils.touch File.join($conf.application_dir, 'packages', 'base.rb')
+    end
+
+    it 'copies package to project folder' do
+      override ['base']
+      File.exists?('packages/base.rb').must_equal true
+    end
+
+    describe 'when copying over existing package' do
+      before(:each) do
+        FileUtils.touch 'packages/base.rb'
+      end
+
+      it 'terminates when user answer no' do
+        $input.string = "n\n"
+        lambda { override ['base'] }.must_output 'Project package already exists. Overwrite? (y/n)
+Aborted.
+'
+      end
+
+      it 'overwrites project package with default package' do
+        $input.string = "y\n"
+        lambda { override ['base'] }.must_output 'Project package already exists. Overwrite? (y/n)
+Package copied to packages/base.rb
+'
+      end
+    end
+  end
+
+  describe 'packages' do
+    it 'displays a list of default and project packages' do
+      FileUtils.mkdir_p File.join($conf.application_dir, 'packages')
+      FileUtils.mkdir_p 'packages'
+      FileUtils.touch File.join($conf.application_dir, 'packages', 'base.rb')
+      FileUtils.touch File.join('packages', 'apps.rb')
+      lambda { packages nil }.must_output 'Default packages
+ * base
+Project packages
+ * apps
+'
+    end
+  end
+
+  describe 'tasks' do
+    it 'displays a list of tasks' do
+      expects(:init)
+      expects(:load_machinesfile)
+      $conf.tasks = {
+        :task1 => {:description => 'description 1'},
+        :task2 =>  {:description => 'description 2'},
+        :task3 => {:description => 'description 3'}
+      }
+      lambda { tasks }.must_output 'Tasks
+  task1                description 1
+  task2                description 2
+  task3                description 3
+'
+    end
+  end
+end
+

data/spec/lib/machines/configuration_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe 'Configuration' do
+  include Machines::Core
+  include Machines::Configuration
+
+  describe 'add_user' do
+    it do
+      command = add_user 'login'
+      command.command.must_equal 'useradd -s /bin/bash -d /home/login -m login'
+      command.check.must_equal "test -d /home/login #{echo_result}"
+    end
+
+    it do
+      command = add_user 'a_user', :password => 'password', :admin => true
+      command.command.must_match /useradd -s \/bin\/bash -d \/home\/a_user -m -p .* -G admin a_user/
+      command.check.must_equal "test -d /home/a_user #{echo_result}"
+    end
+  end
+
+  describe 'add' do
+    it 'add an existing user to a group' do
+      command = add :user => 'phil', :to => 'group'
+      command.command.must_equal 'usermod -a -G group phil'
+    end
+  end
+
+  describe 'configure' do
+    before(:each) do
+      @options = {:string => 'str', :number => 123, :t => true, :f => false, :float => 1.1, :array => ['item 1', 'item 2']}
+    end
+
+    it 'supports different types' do
+      commands = configure @options
+      commands.map(&:command).must_equal [
+        'gconftool-2 --set "string" --type string "str"',
+        'gconftool-2 --set "number" --type int 123',
+        'gconftool-2 --set "t" --type bool true',
+        'gconftool-2 --set "f" --type bool false',
+        'gconftool-2 --set "float" --type float 1.1',
+        'gconftool-2 --set "array" --type list --list-type=string ["item 1","item 2"]'
+      ]
+    end
+
+    it 'checks value has been set' do
+      command = configure 'key' => 'value'
+      command.first.check.must_equal 'gconftool-2 --get "key" | grep "value" ' + echo_result
+    end
+
+    it { lambda{ configure(:invalid_type => Object.new) }.must_raise RuntimeError }
+  end
+
+  describe 'del_user' do
+    it 'calls deluser with remove-all-files option' do
+      subject = del_user 'login'
+      subject.command.must_equal 'deluser login --remove-home -q'
+      subject.check.must_equal "test ! -s /home/login #{echo_result}"
+    end
+  end
+end
+

data/spec/lib/machines/core_spec.rb

@@ -0,0 +1,299 @@
+require 'spec_helper'
+
+describe Machines::Core do
+  include Machines::Core
+  include Machines::FileOperations
+
+  before do
+    @command1 = Machines::Command.new('command 1', 'check 1')
+    @command2 = Machines::Command.new('command 2', 'check 2')
+  end
+
+  describe 'generate_password' do
+    it 'generates a random password' do
+      WEBrick::Utils.stubs(:random_string).with(20).returns '01234567890123456789'
+      generate_password.must_equal '01234567890123456789'
+    end
+  end
+
+  describe 'task' do
+    it 'yields' do
+      yielded = false
+      task :name do
+        yielded = true
+      end
+      yielded.must_equal true
+    end
+
+    it 'logs the task' do
+      task :name, 'description' do
+      end
+      $conf.commands.first.info.must_equal "TASK   name - description"
+    end
+
+    it 'stores task' do
+      block = Proc.new {}
+      task :name, 'description', &block
+      $conf.tasks.must_equal :name => {:description => 'description', :block => block}
+    end
+
+    it 'sets commands to only run those from the specified task' do
+      block_ran = false
+      block = Proc.new { block_ran = true }
+      $conf.tasks[:name] = {:block => block}
+      task :name, nil
+      block_ran.must_equal true
+    end
+
+    describe 'when dependent task' do
+      before(:each) do
+        @yielded = false
+        @block = Proc.new { @yielded = true }
+      end
+
+      describe 'exists' do
+        before(:each) do
+          store_task :dependent_task, nil
+          task :name, nil, :if => :dependent_task, &@block
+        end
+
+        it { @yielded.must_equal true }
+        it 'task stored' do
+          $conf.tasks.must_include :name
+        end
+      end
+
+      describe 'does not exist' do
+        before(:each) { task :name, nil, :if => :dependent_task, &@block }
+        it { @yielded.must_equal false }
+        it 'task not stored' do
+          $conf.tasks.wont_include :name
+        end
+      end
+    end
+
+    describe 'when multiple dependent tasks' do
+      before(:each) do
+        @yielded = false
+        @block = Proc.new { @yielded = true }
+      end
+
+      describe 'all exist' do
+        before(:each) do
+          store_task :dependent_task, nil
+          store_task :another_dependent, nil
+          task :name, nil, :if => [:dependent_task, :another_dependent], &@block
+        end
+
+        it { @yielded.must_equal true }
+        it 'task stored' do
+          $conf.tasks.must_include :name
+        end
+      end
+
+      describe 'all but one exist' do
+        before(:each) do
+          store_task :another_dependent, nil
+          task :name, nil, :if => [:dependent_task, :another_dependent], &@block
+        end
+
+        it { @yielded.must_equal false }
+        it 'task not stored' do
+          $conf.tasks.wont_include :name
+        end
+      end
+    end
+  end
+
+  describe 'list_tasks' do
+    it 'displays a list of tasks' do
+      task :name, 'description', &Proc.new {}
+      task :another, 'another description', &Proc.new {}
+      lambda { list_tasks }.must_output '  name                description
+  another             another description
+'
+    end
+  end
+
+  describe 'only' do
+    it 'yields when matched' do
+      expects(:matched).with('options').returns true
+      yielded = false
+      only 'options' do
+        yielded = true
+      end
+      yielded.must_equal true
+    end
+
+    it 'does not yield when not matched' do
+      expects(:matched).with('options').returns false
+      yielded = false
+      only 'options' do
+        yielded = true
+      end
+      yielded.must_equal false
+    end
+
+    it 'yields when symbol matches string' do
+      $conf.environment = 'development'
+      yielded = false
+      only :environment => :development do
+        yielded = true
+      end
+      yielded.must_equal true
+    end
+  end
+
+  describe 'except' do
+    it 'does not yield when matched' do
+      expects(:matched).with('options').returns true
+      yielded = false
+      except 'options' do
+        yielded = true
+      end
+      yielded.must_equal false
+    end
+
+    it 'yields when not matched' do
+      expects(:matched).with('options').returns false
+      yielded = false
+      except 'options' do
+        yielded = true
+      end
+      yielded.must_equal true
+    end
+  end
+
+  describe 'matched' do
+    describe '$conf values are strings' do
+      before do
+        $conf.string_param = 'matched'
+      end
+
+      it { matched(:string_param => :matched).must_equal true }
+      it { matched(:string_param => 'matched').must_equal true }
+      it { matched(:string_param => :unmatched).wont_equal true }
+    end
+
+    describe '$conf values are arrays' do
+      before do
+        $conf.params_array = [:matched, :another]
+      end
+
+      describe 'options values are arrays of symbols' do
+        it { matched({:params_array => [:matched]}).must_equal true }
+        it { matched({:params_array => [:unmatched]}).wont_equal true }
+      end
+
+      describe 'options values are arrays of strings' do
+        it { matched({'params_array' => ['matched']}).must_equal true }
+        it { matched({'params_array' => ['unmatched']}).wont_equal true }
+      end
+
+      describe 'options values are symbols' do
+        it { matched({:params_array => :matched}).must_equal true }
+        it { matched({:params_array => :unmatched}).wont_equal true }
+      end
+
+      describe 'options values are strings' do
+        it { matched({:params_array => 'matched'}).must_equal true }
+        it { matched({:params_array => 'unmatched'}).wont_equal true }
+      end
+    end
+
+    describe '$conf values are symbols' do
+      before do
+        $conf.single_param = :matched
+      end
+
+      describe 'options values are arrays' do
+        it { matched({:single_param => [:matched]}).must_equal true }
+        it { matched({:single_param => [:unmatched]}).wont_equal true }
+      end
+
+      describe 'options values are symbols' do
+        it { matched({:single_param => :matched}).must_equal true }
+        it { matched({:single_param => :unmatched}).wont_equal true }
+      end
+    end
+  end
+
+  describe 'run' do
+    it 'adds a command to the commands array' do
+      run @command1
+      $conf.commands.must_equal [@command1]
+    end
+
+    it 'appends several commands' do
+      run @command1
+      run @command2
+      $conf.commands.must_equal [@command1, @command2]
+    end
+
+    it 'appends several commands in a single call' do
+      run @command1, @command2
+      $conf.commands.must_equal [@command1, @command2]
+    end
+
+    describe 'when commands are two strings' do
+      it 'creates a Command' do
+        run 'command', 'check'
+        $conf.commands.first.command.must_equal 'command'
+        $conf.commands.first.check.must_equal 'check'
+      end
+    end
+  end
+
+  describe 'sudo' do
+    it 'wraps a command in a sudo with password call' do
+      $conf.password = 'password'
+      @command1.expects(:use_sudo)
+      sudo @command1
+    end
+
+    describe 'when commands are two strings' do
+      it 'creates a Command' do
+        sudo 'command', 'check'
+        $conf.commands.first.command.must_equal 'command'
+        $conf.commands.first.check.must_equal 'check'
+      end
+    end
+  end
+
+  describe 'upload' do
+    subject { upload 'source', 'dest' }
+    it { subject.local.must_equal 'source' }
+    it { subject.remote.must_equal 'dest' }
+  end
+
+  describe 'sudo upload' do
+    it 'modifies Upload to send it to a temp file and sudos to copy it to destination' do
+      File.stubs(:directory?).returns false
+      sudo upload 'source', 'dest'
+
+      $conf.commands.map(&:command).must_equal [nil, "cp -rf /tmp/dest dest", "rm -rf /tmp/dest"]
+      $conf.commands.map(&:check).must_equal [
+        "test -s /tmp/dest && echo CHECK PASSED || echo CHECK FAILED",
+        "test -s dest && echo CHECK PASSED || echo CHECK FAILED",
+        "test ! -s /tmp/dest && echo CHECK PASSED || echo CHECK FAILED"
+      ]
+    end
+
+    it 'adds /. to the end of folder paths' do
+      File.stubs(:directory?).with('source').returns true
+      sudo upload 'source', 'dest'
+      $conf.commands.map(&:command).must_equal [nil, "cp -rf /tmp/dest/. dest", "rm -rf /tmp/dest"]
+    end
+  end
+
+  describe 'required_options' do
+    it 'does not raise when option exists' do
+      required_options({:required => :option}, [:required])
+    end
+
+    it 'raises when option does not exist' do
+      lambda{required_options({}, [:required])}.must_raise(ArgumentError)
+    end
+  end
+end
+

data/spec/lib/machines/database_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'Database' do
+  include Machines::Core
+  include Machines::Configuration
+  include Machines::Database
+  include Machines::AppSettings
+  include Machines::FileOperations
+
+  describe 'write_database_yml' do
+    before do
+      $conf.environment = 'staging'
+      $conf.db_server = AppConf.new
+      $conf.db_server.address = 'dbhost'
+    end
+
+    it 'supplies correct parameters' do
+      file = write_database_yml AppBuilder.new(:name => 'app', :password => 'password', :path => 'path')
+      file.local.read.must_equal <<-EOF
+---
+staging:
+  adapter: mysql
+  database: app
+  username: app
+  password: password
+  host: dbhost
+  encoding: utf8
+EOF
+    end
+
+    it 'writes file to specified path' do
+      file = write_database_yml AppBuilder.new(:name => 'app', :password => 'password', :path => 'path')
+      file.remote.must_equal 'path/shared/config/database.yml'
+    end
+
+    it 'overrides database name when supplied' do
+      file = write_database_yml AppBuilder.new(:name => 'app', :password => 'password', :username => 'phil', :database => 'myapp', :path => 'path')
+      file.local.read.must_equal <<-EOF
+---
+staging:
+  adapter: mysql
+  database: myapp
+  username: phil
+  password: password
+  host: dbhost
+  encoding: utf8
+EOF
+    end
+  end
+end
+