stackfu 0.1.0

data/test/fixtures/users_update

@@ -0,0 +1,6 @@
+HTTP/1.1 200 OK
+Connection: close
+Date: Sat, 14 Nov 2009 17:34:12 GMT
+Content-Type: application/json;charset=utf-8
+Content-Length: 0
+

data/test/stack.yml

@@ -0,0 +1,26 @@
+--- 
+type: 
+name: "test"
+#
+# TODO: Before submitting this stack, you have to specify
+# the attributes below.
+#
+# Available operating systems
+#
+# For OS               Use
+# -------------------- --------------------
+# Debian 5.0           debian_50
+# Gentoo 2008          gentoo_2008
+# Ubuntu 8.10          ubuntu_810
+# Fedora 10            fedora_10
+# Arch 2009            arch_2009
+# Ubuntu 9.04          ubuntu_904
+# Centos 5.2           centos_52
+# ArchLinux 2009       arch_2009
+# Ubuntu 8.04          ubuntu_804
+# Centos 5.3           centos_53
+#
+# operating_system: 
+# description: "Enter a description for this stack here"
+# tags: [add, some, tags]
+#

data/test/support/custom_matchers.rb

@@ -0,0 +1,69 @@
+module CustomMatchers
+  custom_matcher :be_nil do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be nil but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be nil but it was"
+    receiver.nil?
+  end
+  
+  custom_matcher :be_blank do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be blank but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be blank but it was"
+    receiver.blank?
+  end
+  
+  custom_matcher :be_true do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be true but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be true but it was"
+    receiver.eql?(true)
+  end
+  
+  custom_matcher :be_false do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be false but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be false but it was"
+    receiver.eql?(false)
+  end
+
+  custom_matcher :be_valid do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected to be valid but it was invalid #{receiver.errors.inspect}"
+    matcher.negative_failure_message = "Expected to be invalid but it was valid #{receiver.errors.inspect}"
+    receiver.valid?
+  end
+  
+  custom_matcher :be_of_type do |receiver, matcher, args|
+    klass = args[0]
+    matcher.positive_failure_message = "Expected #{receiver} to be of type #{klass} but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} to not be of type #{klass} but it was"
+    receiver.kind_of?(klass)
+  end
+  
+  custom_matcher :start_with do |receiver, matcher, args|
+    s = args[0]
+    matcher.positive_failure_message = "Expected #{receiver} to start with '#{s}' but it didn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to start with '#{s}' but it did"
+    true if receiver =~ /^#{s}/
+  end
+  
+  custom_matcher :have_error_on do |receiver, matcher, args|
+    receiver.valid?
+    attribute = args[0]
+    expected_message = args[1]
+    
+    if expected_message.nil?
+      matcher.positive_failure_message = "#{receiver} had no errors on #{attribute}"
+      matcher.negative_failure_message = "#{receiver} had errors on #{attribute} #{receiver.errors.inspect}"
+      !receiver.errors.on(attribute).blank?
+    else
+      actual = receiver.errors.on(attribute)
+      matcher.positive_failure_message = %Q(Expected error on #{attribute} to be "#{expected_message}" but was "#{actual}")
+      matcher.negative_failure_message = %Q(Expected error on #{attribute} not to be "#{expected_message}" but was "#{actual}")
+      actual == expected_message
+    end
+  end
+  
+  custom_matcher :have_index do |receiver, matcher, args|
+    index_name = args[0]
+    matcher.positive_failure_message = "#{receiver} does not have index named #{index_name}, but should"
+    matcher.negative_failure_message = "#{receiver} does have index named #{index_name}, but should not"
+    !receiver.collection.index_information.detect { |index| index[0] == index_name }.nil?
+  end
+end

data/test/support/fixtures.rb

@@ -0,0 +1,98 @@
+module Fixtures
+  ApiUrlPrefix = StackFu::API.gsub(/api/, "flipper:abc123@api")
+
+  def with_logs(id, kind=nil)
+    register :get, :path => "deployments/#{id}/logs", :kind => kind
+  end
+
+  def with_providers(kind=nil)
+    register :get, :path => "providers", :kind => kind
+  end
+  
+  def with_provider(id, kind=nil)
+    register :get, :path => "providers/#{id}/#{kind}", :fixture => "providers", :kind => kind
+  end
+  
+  def with_stacks(kind=nil, params=nil)
+    register :get, :path => "stacks", :kind => kind, :params => params
+  end
+  
+  def with_stack_add(kind=nil)
+    register :post, :path => "stacks", :fixture => "stack_add", :kind => kind
+  end
+  
+  def with_stack_delete(id=nil, fixture="stack_add", kind=nil)
+    register :delete, :path => "stacks/#{id}", :fixture => fixture, :kind => kind
+  end
+  
+  def with_plugins(kind=nil, params=nil)
+    register :get, :path => "plugins", :kind => kind, :params => params
+  end
+  
+  def with_plugin_add(kind=nil)
+    register :post, :path => "plugins", :fixture => "plugin_add", :kind => kind
+  end
+  
+  def with_plugin_delete(id=nil, fixture="plugin_add", kind=nil)
+    register :delete, :path => "plugins/#{id}", :fixture => fixture, :kind => kind
+  end
+  
+  def with_server_list(kind=nil, params=nil)
+    register :get, :path => "servers", :kind => kind, :params => params
+  end
+  
+  def with_server_add(kind=nil)
+    register :post, :path => "servers", :fixture => "server_add", :kind => kind
+  end
+
+  def with_server_delete(kind=nil)
+    register :delete, :path => "servers/4afe06b9e1054e1e00000002", :fixture => "server_add", :kind => kind
+  end
+
+  def with_user(id, kind=nil)
+    register :get, :path => "users/#{id}/#{kind}", :fixture => "users", :kind => kind
+  end
+
+  def with_users(kind=nil)
+    register :get, :path => "users", :kind => kind
+  end
+
+  def with_users_add(kind=nil)
+    register :post, :path => "users", :fixture => "users_update", :kind => kind
+  end
+  
+  def with_users_update(id=nil, kind=nil)
+    register :put, :path => "users#{id ? "/#{id}" : ""}", :fixture => "users_update", :kind => kind
+  end
+  
+  def with_new_deployment(kind=nil)
+    register :post, :path => "deployments", :fixture => "deployment_add", :kind => kind
+  end
+
+  def with_new_plugin_deployment(kind=nil)
+    register :post, :path => "deployments", :fixture => "plugin_deployment_add", :kind => kind
+  end
+
+  private
+
+  def register(method, options) # path, kind, fixture=path)
+    kind = options[:kind] ? "_#{options[:kind]}" : ""
+    path = options[:path] or raise "path is mandatory"
+    fixture = options[:fixture] || options[:path]
+    params = options[:params] ? "?#{options[:params]}" : ""
+    
+    # d "Registering: #{method} #{ApiUrlPrefix}/#{path}.json#{params} => #{fixture}#{kind}"
+    FakeWeb.register_uri(method, "#{ApiUrlPrefix}/#{path}.json#{params}", 
+      :response => fixture("#{fixture}#{kind}"))
+  end
+  
+  def fixture(*path)
+    file_name = File.join(File.dirname(__FILE__), "../fixtures", path)
+    raise "Fixture #{file_name} was not found" unless File.exists?(file_name)
+    file_name
+  end
+
+  def fixture_contents(*path)
+    File.open(File.join(File.dirname(__FILE__), "../fixtures", path), "r").readlines.join("")
+  end
+end

data/test/support/io_stub.rb

@@ -0,0 +1,10 @@
+module IoStub
+  def stdout
+    $stdout.rewind
+    $stdout.read
+  end
+  
+  def debug(s)
+    @orig_stdout.puts s
+  end
+end

data/test/support/web_fixtures.rb

@@ -0,0 +1,91 @@
+module WebFixtures
+  def stub_file(*path)
+    File.join(File.dirname(__FILE__), "../stubs", path)
+  end
+
+  def stub_file_contents(*path)
+    File.open(File.join(File.dirname(__FILE__), "../stubs", path), "r").readlines.join("")
+  end
+
+  def fake_webby_os(os)
+    yaml_api = "https://manager.webbynode.com/api/yaml"
+
+    response = stub_file_contents("webbynode", "fcoury@me.com", "webbies")
+    response.gsub! ":os_template: 32", ":os_template: #{os}"
+
+    FakeWeb.clean_registry
+    FakeWeb.register_uri(:post, "#{yaml_api}/webbies", :response => response)
+  end
+
+  def fake_webbynode
+    FakeWeb.clean_registry
+    yaml_api = "https://manager.webbynode.com/api/yaml"
+
+    users = {
+      "fcoury@me.com" => "1da75b299084548ccd84990e463d4266e96abc5a",
+      "ctab@me.com"   => "2da127cbffd4266e96abc5a8bbc671e1c2bb3bac",
+    }
+
+    fakes = {
+      "webbies" => "webbies",
+      "client"  => "client"
+    }
+
+    users.each_pair do |email, token|
+      fakes.each_pair do |key, value|
+        FakeWeb.register_uri(:post, "#{yaml_api}/#{key}", :email => email, :response => stub_file("webbynode", email, value))
+      end
+    end
+  end
+  
+  SlicehostUsers = {
+    "felipe.coury@gmail.com" => "6ed05e7521dfb6a19c98a84f2d0a28fdffc1bf00e050fe7114a66d3049e9715e"
+  }
+
+  def fake_slicehost
+    FakeWeb.clean_registry
+
+    SlicehostUsers.each_pair do |email, token|
+      slicehost_register(:get, "/slices.xml", "slices")
+    end
+  end
+  
+  def fake_slicehost_no_slice
+    FakeWeb.clean_registry
+
+    SlicehostUsers.each_pair do |email, token|
+      slicehost_register(:get, "/slices.xml", "slices_none")
+    end
+  end
+
+  def fake_slicehost_os(os)
+    user = SlicehostUsers.keys.first
+    token = SlicehostUsers.values.first
+
+    xml_api = "https://#{token}@api.slicehost.com"
+
+    response = stub_file_contents("slicehost", user, "slices")
+    response.gsub! "Content-Length: 554", "Content-Length: 553" if os.to_s.size < 2
+    response.gsub! '<image-id type="integer">10</image-id>', "<image-id type=\"integer\">#{os}</image-id>"
+
+    FakeWeb.clean_registry
+    FakeWeb.register_uri(:get, "#{xml_api}/slices.xml", :response => response)
+  end
+
+  def fake_slice_creation(success=true)
+    slicehost_register :post, "/slices.xml", "create_slice"
+  end
+
+  def fake_slice_deletion(slice_id, error="")
+    slicehost_register :delete, "/slices/#{slice_id}.xml", "delete_slice#{error.present? ? "_#{error}" : ""}"
+  end
+  
+  def slicehost_register(method, uri, file, user=SlicehostUsers.keys.first)
+    token = SlicehostUsers[user]
+    
+    file = stub_file("slicehost", user, file)
+    prefix = "https://#{token}@api.slicehost.com"
+    
+    FakeWeb.register_uri(method, "#{prefix}#{uri}", :response => file)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,186 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/stackfu')
+
+gem 'fcoury-matchy', '0.4.0'
+gem 'shoulda', '2.10.2'
+gem 'timecop', '0.3.1'
+gem 'mocha', '>=0.9.4'
+gem 'fakeweb', '>=1.2.7'
+gem 'phocus', '>=1.1'
+gem 'uuid', '>=2.0.2'
+
+require 'matchy'
+require 'shoulda'
+require 'fakeweb'
+require 'phocus'
+require 'mocha'
+require 'uuid'
+require 'pp'
+
+require 'support/custom_matchers'
+require 'support/io_stub'
+require 'support/fixtures'
+
+HighLine.track_eof = false
+FakeWeb.allow_net_connect = false
+$testing = true
+
+class Test::Unit::TestCase
+  include CustomMatchers
+  include IoStub
+  include Fixtures
+  include StackFu
+
+  def command(cmd, settings_present=true)
+    cmd ||= ""
+    App.expects(:settings?).returns(settings_present)
+    if settings_present
+      App.any_instance.expects(:load_config).returns({ :login => "flipper", :token => "abc123" })
+    end
+    App.new(cmd.split(" ")).start
+  end
+
+  def setup
+    FakeWeb.clean_registry
+    @orig_stdout = $stdout
+    $stdout = StringIO.new
+    $actions = []
+    $asked = []
+  end
+  
+  def when_asked_to_choose(what, options)
+    $actions << { :type => "choose", :action => options.merge(:prompt => what) }
+  end
+  
+  def when_asked(what, options)
+    $actions << { :type => "ask", :action => [what, options[:answer]] }
+  end
+  
+  def agree_with(what)
+    $actions << { :type => "agree", :action => what }
+  end
+  
+  def disagree_of(what)
+    $actions << { :type => "disagree", :action => what }
+  end
+  
+  def teardown
+    $stdout = @orig_stdout
+    asked = $asked.map { |s| "  - #{s}" }.join("\n")
+    unless $actions.empty?
+      questions = $actions.map do |q| 
+        info = case q[:type]
+        when "ask"
+          q[:action].first
+        
+        when "choose"
+          txt = "'#{q[:action][:prompt]}'"
+          txt << " with options '#{q[:action][:with_options].join(", ")}'" if q[:action][:with_options]
+        else
+          q[:action]
+        end
+        
+        "  - #{q[:type]} #{info}" 
+      end.join("\n")
+      fail "Expected questions not asked:\n#{questions}\nQuestions responded:\n#{asked}\n"
+    end
+  end
+end
+
+module StackFu
+  class ConfigCommand
+    def save_config(login, token)
+    end
+  end
+end
+
+class Array
+  def delete_first(value=nil)
+    result = nil
+    self.each_index do |i|
+      if block_given? and yield(self[i])
+        result = self.delete_at(i)
+        break
+      end 
+      if value and self[i] == value
+        result = self.delete_at(i) 
+        break 
+      end
+    end
+    
+    return result unless result and result.empty?
+  end
+end
+
+module Kernel
+  def choose(*items, &details)
+    if (action = $actions.first)
+      if action[:type] == "choose"
+        item = OpenStruct.new
+        class << item
+          def choice(*args)
+            (self.choices||=[]) << args
+          end
+        end
+        
+        details.call item
+        
+        exp_action = $actions.shift[:action]
+        item.prompt.should == exp_action[:prompt]
+        
+        exp_action[:with_options].try(:each) do |opt|
+          item.choices.flatten.include?(opt).should == true
+        end
+        
+        if (answer = exp_action[:answer]).is_a?(Numeric)
+          item.choices[answer][0]
+        else
+          answer
+        end
+      end
+    else
+      fail "Unexpected choose"
+    end
+  end
+  
+  def ask(question, answer_type = String, &details)
+    if (action = $actions.first)
+      matches = if (expected = action[:action].first).is_a?(Regexp)
+        question =~ expected
+      else
+        question == expected
+      end
+
+      if action[:type] == "ask" and matches
+        $asked << "responded to ask #{action[:action].first} with #{action[:action].last}"
+        exp_action = $actions.shift
+        result = exp_action[:action].last
+        return result
+      end
+    
+      fail "Expected to #{action[:type]} #{action[:action].inspect} but asked #{question.inspect}"
+    else
+      fail "Unexpected ask #{question.inspect}"
+    end
+  end
+  
+  def agree(yes_or_no_question, character = nil)
+    action = $actions.first
+    if action and action[:action] == yes_or_no_question
+      if action[:type] == "agree" or action[:type] == "disagree"
+        $asked << "#{action[:type]}d to #{action[:action]}"
+        result = $actions.shift[:type] == "agree"
+        # d "#{action[:type]} #{yes_or_no_question} => #{result}"
+        return result
+      end
+    end
+    
+    if action
+      fail "Expected to #{action[:type]} #{action[:action].inspect} but asked to agree with #{yes_or_no_question.inspect}"
+    else
+      fail "Unexpected agreement #{yes_or_no_question.inspect}"
+    end
+  end
+end
+
+def d(x); $stderr.puts x; end
+def ppd(x); $stderr.puts x.pretty_inspect; end

data/test/unit/commands/test_command.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/../../test_helper.rb'
+
+class SampleCmd < StackFu::Command
+end
+
+class TestCommand < Test::Unit::TestCase
+  should "return true to params? if params given" do
+    SampleCmd.new(["hello", "world"]).params?.should be_true
+  end
+  
+  should "return false to params? if params given" do
+    SampleCmd.new(["--hello", "--world"]).params?.should be_false
+  end
+  
+  should "allow command with no subcommand" do
+    cmd = SampleCmd.new(["--force"])
+    cmd.subcommand.should == :default
+    cmd.parameters.should == []
+    cmd.options.should == { :force => true }
+    
+    cmd = SampleCmd.new(["mine", "yellow", "--azul=b"])
+    cmd.subcommand.should == :mine
+    cmd.parameters.should == ["yellow"]
+    cmd.options.should == { :azul => "b" }
+  end
+  
+  should "parse as parameter if = is present" do
+    cmd = SampleCmd.new(["--force", "--ssh_passphrase="])
+    cmd.options.should == { :force => true, :ssh_passphrase => "" }
+  end
+  
+  should "parse subcommand and options" do
+    cmd = SampleCmd.new(["copy", "--force", "/var/opt/music/mine.mp3", "/home/fcoury"])
+    cmd.subcommand.should == :copy
+    cmd.parameters.should == ["/var/opt/music/mine.mp3", "/home/fcoury"]
+    cmd.options.should == { :force => true }
+
+    cmd = SampleCmd.new(["move", "/var/log/1.log", "--mode=FAILSAFE", "/var/log/one.log"])
+    cmd.subcommand.should == :move
+    cmd.parameters.should == ["/var/log/1.log", "/var/log/one.log"]
+    cmd.options.should == { :mode => "FAILSAFE" }
+  end
+  
+  should "allow commands to have aliases" do
+    SampleCmd.aliases "smp", "sampoo"
+    Command.create("smp").class.should == SampleCmd
+    Command.create("sampoo").class.should == SampleCmd
+  end
+  
+  should "be valid if only a default subcommand exists" do
+    SampleCmd.new.should be_valid
+  end
+  
+  should "allow named parameters" do
+    class NewCmd < Command
+      subcommand :move, :required_parameters => [:provider, :server_name]
+    end
+
+    lambda { 
+      cmd = NewCmd.new(["move"]) 
+    }.should raise_error(Exceptions::InvalidCommand, /requires 2 parameters/)
+  end
+  
+  should "inflex the requirement error" do
+    class NewCmd < Command
+      subcommand :move, :required_parameters => [:server_name]
+    end
+
+    lambda { 
+      cmd = NewCmd.new(["move"]) 
+    }.should raise_error(Exceptions::InvalidCommand, /requires 1 parameter\./)
+  end
+  
+  should "allow subcommand aliases" do
+    class Cmd < Command
+      alias_subcommand :list => :default
+    end
+    
+    cmd = Cmd.new(["list"])
+    cmd.subcommand.should == :default
+  end
+  
+  should "throw a specific exception when subcommand doesn't exist" do
+    class ListCommand < Command
+    end
+    
+    lambda {
+      ListCommand.new(["find"]).run
+    }.should raise_error(Exceptions::InvalidCommand, /Command list doesn't have a subcommand "find". Try "stackfu list help" for more information./)
+  end
+  
+  should "allow the error message for inexistent subcommand to be customized" do
+    class ExampleCommand < Command
+      error_messages :missing_subcommand => "There's no such thing as %s"
+    end
+
+    lambda {
+      ExampleCommand.new(["test"]).run
+    }.should raise_error(Exceptions::InvalidCommand, /There's no such thing as test/)
+  end
+  
+  should "allow the error message for missing params to be customized" do
+    class ExampleCommand < Command
+      subcommand :test, :required_parameters => [:sex, :age]
+      error_messages :missing_params => "You have to provide sex and age, dude!"
+    end
+
+    lambda {
+      ExampleCommand.new(["test"]).run
+    }.should raise_error(Exceptions::InvalidCommand, /You have to provide sex and age, dude!/)
+  end
+end

data/test/unit/commands/test_config_command.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../../test_helper.rb'
+
+class TestConfigCommand < Test::Unit::TestCase
+  context "provider command" do
+    should "recognize Webbynode" do
+      with_users
+      with_users_update("4afe06b8e1054e1e00000001")
+      
+      when_asked "Webbynode Login:", :answer => "fcoury@me.com"
+      when_asked "Webbynode Token:", :answer => "abc123"
+      
+      command "config webbynode"
+      stdout.should =~ /Webbynode credentials saved./
+    end
+
+    should "recognize Webbynode" do
+      with_users
+      with_users_update("4afe06b8e1054e1e00000001")
+      
+      when_asked "Webbynode Login:", :answer => "fcoury@me.com"
+      when_asked "Webbynode Token:", :answer => "abc123"
+      
+      command "config webbynode"
+      stdout.should =~ /Webbynode credentials saved./
+    end
+
+    should "recognize Slicehost" do
+      with_users
+      with_users_update("4afe06b8e1054e1e00000001")
+      
+      when_asked "", :answer => "6ed05e7521dfb6a19c98a84f2d0a28fdffc1bf00e050fe7114a66d3049e9715e"
+      
+      command "config slicehost"
+      stdout.should =~ /Slicehost credentials saved./
+    end
+  end
+  
+  context "default command" do
+    should "skip asking login, token and confirmation if --login and --token provided" do
+      ConfigCommand.any_instance.expects(:save_config).with("flipper", "abc123")
+      command "config --login=flipper --token=abc123"
+      stdout.should =~ /Configuration saved/
+    end
+
+    should "skip asking login if --login provided" do
+      when_asked "StackFu Token: ", :answer => "abc123"
+
+      agree_with "Is this information correct? "
+
+      ConfigCommand.any_instance.expects(:save_config).with("flipper", "abc123")
+      command "config --login=flipper"
+      stdout.should =~ /Configuration saved/
+    end
+
+    should "skip asking token if --token provided" do
+      when_asked "StackFu Login: ", :answer => "flipper"
+
+      agree_with "Is this information correct? "
+
+      ConfigCommand.any_instance.expects(:save_config).with("flipper", "abc123")
+      command "config --token=abc123"
+      stdout.should =~ /Configuration saved/
+    end
+
+    should "Ask the login, token and offer to add a new server" do
+      when_asked "StackFu Login: ", :answer => "flipper"
+      when_asked "StackFu Token: ", :answer => "abc123"
+
+      agree_with "Is this information correct? "
+
+      ConfigCommand.any_instance.expects(:save_config).with("flipper", "abc123")
+      command "config"
+      stdout.should =~ /Configuration saved/
+    end
+
+    should "Ask the login, token again if information not correct" do
+      when_asked "StackFu Login: ", :answer => "flipper"
+      when_asked "StackFu Token: ", :answer => "abc123"
+
+      disagree_of "Is this information correct? "
+
+      when_asked "StackFu Login: ", :answer => "flipper"
+      when_asked "StackFu Token: ", :answer => "abc123"
+
+      agree_with "Is this information correct? "
+
+      ConfigCommand.any_instance.expects(:save_config).with("flipper", "abc123")
+      command "config" 
+      stdout.should =~ /Configuration saved/
+    end
+  end
+end