azuki 0.0.1

data/spec/azuki/helpers/azuki_postgresql_spec.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+require "azuki/helpers/azuki_postgresql"
+
+include Azuki::Helpers::AzukiPostgresql
+
+describe Azuki::Helpers::AzukiPostgresql do
+
+  before do
+    subject.forget_config!
+    subject.stub(:app_config_vars) { app_config_vars }
+    subject.stub(:app_attachments) { app_attachments }
+  end
+
+  let(:app_config_vars) do
+    {
+      "DATABASE_URL"                => "postgres://default",
+      "AZUKI_POSTGRESQL_BLACK_URL" => "postgres://black",
+      "AZUKI_POSTGRESQL_IVORY_URL" => "postgres://default",
+      "SHARED_DATABASE_URL"         => "postgres://shared"
+    }
+  end
+
+    let(:app_attachments) {
+      [ Attachment.new({ 'config_var' => 'AZUKI_POSTGRESQL_IVORY_URL',
+          'resource' => {'name'  => 'softly-mocking-123',
+                         'value' => 'postgres://default',
+                         'type'  => 'azuki-postgresql:baku' }}),
+        Attachment.new({ 'config_var' => 'AZUKI_POSTGRESQL_BLACK_URL',
+          'resource' => {'name'  => 'quickly-yelling-2421',
+                         'value' => 'postgres://black',
+                         'type'  => 'azuki-postgresql:zilla' }})
+      ]
+    }
+
+  context "when the DATABASE_URL has query options" do
+    let(:app_config_vars) do
+      {
+        "DATABASE_URL"                => "postgres://default?pool=15",
+        "AZUKI_POSTGRESQL_BLACK_URL" => "postgres://black",
+        "AZUKI_POSTGRESQL_IVORY_URL" => "postgres://default",
+        "SHARED_DATABASE_URL"         => "postgres://shared"
+      }
+    end
+
+    it "resolves DATABASE" do
+      att = subject.hpg_resolve('DATABASE')
+      att.display_name.should == "AZUKI_POSTGRESQL_IVORY_URL (DATABASE_URL)"
+      att.url.should == "postgres://default"
+    end
+  end
+
+  context "when the DATABASE_URL has no query options" do
+    let(:app_config_vars) do
+      {
+        "DATABASE_URL"                => "postgres://default",
+        "AZUKI_POSTGRESQL_BLACK_URL" => "postgres://black",
+        "AZUKI_POSTGRESQL_IVORY_URL" => "postgres://default",
+        "SHARED_DATABASE_URL"         => "postgres://shared"
+      }
+    end
+
+    it "resolves DATABASE" do
+      att = subject.hpg_resolve('DATABASE')
+      att.display_name.should == "AZUKI_POSTGRESQL_IVORY_URL (DATABASE_URL)"
+      att.url.should == "postgres://default"
+    end
+  end
+
+  it "resolves SHARED_DATABASE" do
+    att = subject.hpg_resolve('SHARED_DATABASE')
+    att.display_name.should == "SHARED_DATABASE"
+    att.url.should == "postgres://shared"
+  end
+
+  it "resolves default using NAME" do
+    att = subject.hpg_resolve('IVORY')
+    att.display_name.should == "AZUKI_POSTGRESQL_IVORY_URL (DATABASE_URL)"
+    att.url.should == "postgres://default"
+  end
+
+  it "resolves non-default using NAME" do
+    att = subject.hpg_resolve('BLACK')
+    att.display_name.should == "AZUKI_POSTGRESQL_BLACK_URL"
+    att.url.should == "postgres://black"
+  end
+
+  it "resolves default using NAME_URL" do
+    att = subject.hpg_resolve('IVORY_URL')
+    att.display_name.should == "AZUKI_POSTGRESQL_IVORY_URL (DATABASE_URL)"
+    att.url.should == "postgres://default"
+  end
+
+  it "resolves non-default using NAME_URL" do
+    att = subject.hpg_resolve('BLACK_URL')
+    att.display_name.should == "AZUKI_POSTGRESQL_BLACK_URL"
+    att.url.should == "postgres://black"
+  end
+
+  it "resolves default using lowercase" do
+    att = subject.hpg_resolve('ivory')
+    att.display_name.should == "AZUKI_POSTGRESQL_IVORY_URL (DATABASE_URL)"
+    att.url.should == "postgres://default"
+  end
+
+  it "resolves non-default using lowercase" do
+    att = subject.hpg_resolve('black')
+    att.display_name.should == "AZUKI_POSTGRESQL_BLACK_URL"
+    att.url.should == "postgres://black"
+  end
+
+  it "resolves non-default using part of name" do
+    att = subject.hpg_resolve('bla')
+    att.display_name.should == "AZUKI_POSTGRESQL_BLACK_URL"
+    att.url.should == "postgres://black"
+  end
+
+  it "throws an error if it doesnt exist" do
+    subject.should_receive(:error).with("Unknown database: violet. Valid options are: DATABASE_URL, AZUKI_POSTGRESQL_BLACK_URL, AZUKI_POSTGRESQL_IVORY_URL, SHARED_DATABASE")
+    subject.hpg_resolve("violet")
+  end
+
+  context "default" do
+
+    it "errors if there is no default" do
+      subject.should_receive(:error).with("Unknown database. Valid options are: DATABASE_URL, AZUKI_POSTGRESQL_BLACK_URL, AZUKI_POSTGRESQL_IVORY_URL, SHARED_DATABASE")
+      subject.hpg_resolve(nil)
+    end
+
+    it "uses the default if nothing(nil) specified" do
+      att = subject.hpg_resolve(nil, "DATABASE_URL")
+      att.display_name.should == "AZUKI_POSTGRESQL_IVORY_URL (DATABASE_URL)"
+      att.url.should == "postgres://default"
+    end
+
+    it "uses the default if nothing(empty) specified" do
+      att = subject.hpg_resolve('', "DATABASE_URL")
+      att.display_name.should == "AZUKI_POSTGRESQL_IVORY_URL (DATABASE_URL)"
+      att.url.should == "postgres://default"
+    end
+
+    it 'throws an error if given an empty string and asked for the default and there is no default' do
+      app_config_vars.delete 'DATABASE_URL'
+      subject.should_receive(:error).with("Unknown database. Valid options are: AZUKI_POSTGRESQL_BLACK_URL, AZUKI_POSTGRESQL_IVORY_URL, SHARED_DATABASE")
+      att = subject.hpg_resolve('', "DATABASE_URL")
+    end
+
+    it 'throws an error if given an empty string and asked for the default and the default doesnt match' do
+      app_config_vars['DATABASE_URL'] = 'something different'
+      subject.should_receive(:error).with("Unknown database. Valid options are: AZUKI_POSTGRESQL_BLACK_URL, AZUKI_POSTGRESQL_IVORY_URL, SHARED_DATABASE")
+      att = subject.hpg_resolve('', "DATABASE_URL")
+    end
+
+
+  end
+end

data/spec/azuki/helpers_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "azuki/helpers"
+
+module Azuki
+  describe Helpers do
+    include Azuki::Helpers
+
+    context "display_object" do
+
+      it "should display Array correctly" do
+        capture_stdout do
+          display_object([1,2,3])
+        end.should == <<-OUT
+1
+2
+3
+OUT
+      end
+
+      it "should display { :header => [] } list correctly" do
+        capture_stdout do
+          display_object({:first_header => [1,2,3], :last_header => [7,8,9]})
+        end.should == <<-OUT
+=== first_header
+1
+2
+3
+
+=== last_header
+7
+8
+9
+
+OUT
+      end
+
+      it "should display String properly" do
+        capture_stdout do
+          display_object('string')
+        end.should == <<-OUT
+string
+OUT
+      end
+
+    end
+
+  end
+end

data/spec/azuki/plugin_spec.rb

@@ -0,0 +1,172 @@
+require "spec_helper"
+require "azuki/plugin"
+
+module Azuki
+  describe Plugin do
+    include SandboxHelper
+
+    it "lives in ~/.azuki/plugins" do
+      Plugin.stub!(:home_directory).and_return('/home/user')
+      Plugin.directory.should == '/home/user/.azuki/plugins'
+    end
+
+    it "extracts the name from git urls" do
+      Plugin.new('git://github.com/azuki/plugin.git').name.should == 'plugin'
+    end
+
+    describe "management" do
+      before(:each) do
+        @sandbox = "/tmp/azuki_plugins_spec_#{Process.pid}"
+        FileUtils.mkdir_p(@sandbox)
+        Dir.stub!(:pwd).and_return(@sandbox)
+        Plugin.stub!(:directory).and_return(@sandbox)
+      end
+
+      after(:each) do
+        FileUtils.rm_rf(@sandbox)
+      end
+
+      it "lists installed plugins" do
+        FileUtils.mkdir_p(@sandbox + '/plugin1')
+        FileUtils.mkdir_p(@sandbox + '/plugin2')
+        Plugin.list.should include 'plugin1'
+        Plugin.list.should include 'plugin2'
+      end
+
+      it "installs pulling from the plugin url" do
+        plugin_folder = "/tmp/azuki_plugin"
+        FileUtils.mkdir_p(plugin_folder)
+        `cd #{plugin_folder} && git init && echo 'test' > README && git add . && git commit -m 'my plugin'`
+        Plugin.new(plugin_folder).install
+        File.directory?("#{@sandbox}/azuki_plugin").should be_true
+        File.read("#{@sandbox}/azuki_plugin/README").should == "test\n"
+      end
+
+      it "reinstalls over old copies" do
+        plugin_folder = "/tmp/azuki_plugin"
+        FileUtils.mkdir_p(plugin_folder)
+        `cd #{plugin_folder} && git init && echo 'test' > README && git add . && git commit -m 'my plugin'`
+        Plugin.new(plugin_folder).install
+        Plugin.new(plugin_folder).install
+        File.directory?("#{@sandbox}/azuki_plugin").should be_true
+        File.read("#{@sandbox}/azuki_plugin/README").should == "test\n"
+      end
+
+      context "update" do
+
+        before(:each) do
+          plugin_folder = "/tmp/azuki_plugin"
+          FileUtils.mkdir_p(plugin_folder)
+          `cd #{plugin_folder} && git init && echo 'test' > README && git add . && git commit -m 'my plugin'`
+          Plugin.new(plugin_folder).install
+          `cd #{plugin_folder} && echo 'updated' > README && git add . && git commit -m 'my plugin update'`
+        end
+
+        it "updates existing copies" do
+          Plugin.new('azuki_plugin').update
+          File.directory?("#{@sandbox}/azuki_plugin").should be_true
+          File.read("#{@sandbox}/azuki_plugin/README").should == "updated\n"
+        end
+
+        it "warns on legacy plugins" do
+          `cd #{@sandbox}/azuki_plugin && git config --unset branch.master.remote`
+          stderr = capture_stderr do
+            begin
+              Plugin.new('azuki_plugin').update
+            rescue SystemExit
+            end
+          end
+          stderr.should == <<-STDERR
+ !    azuki_plugin is a legacy plugin installation.
+ !    Enable updating by reinstalling with `azuki plugins:install`.
+STDERR
+        end
+
+        it "raises exception on symlinked plugins" do
+          `cd #{@sandbox} && ln -s azuki_plugin azuki_plugin_symlink`
+          lambda { Plugin.new('azuki_plugin_symlink').update }.should raise_error Azuki::Plugin::ErrorUpdatingSymlinkPlugin
+        end
+
+      end
+
+
+      it "uninstalls removing the folder" do
+        FileUtils.mkdir_p(@sandbox + '/plugin1')
+        Plugin.new('git://github.com/azuki/plugin1.git').uninstall
+        Plugin.list.should == []
+      end
+
+      it "adds the lib folder in the plugin to the load path, if present" do
+        FileUtils.mkdir_p(@sandbox + '/plugin/lib')
+        File.open(@sandbox + '/plugin/lib/my_custom_plugin_file.rb', 'w') { |f| f.write "" }
+        Plugin.load!
+        lambda { require 'my_custom_plugin_file' }.should_not raise_error(LoadError)
+      end
+
+      it "loads init.rb, if present" do
+        FileUtils.mkdir_p(@sandbox + '/plugin')
+        File.open(@sandbox + '/plugin/init.rb', 'w') { |f| f.write "LoadedInit = true" }
+        Plugin.load!
+        LoadedInit.should be_true
+      end
+
+      describe "when there are plugin load errors" do
+        before(:each) do
+          FileUtils.mkdir_p(@sandbox + '/some_plugin/lib')
+          File.open(@sandbox + '/some_plugin/init.rb', 'w') { |f| f.write "require 'some_non_existant_file'" }
+        end
+
+        it "should not throw an error" do
+          capture_stderr do
+            lambda { Plugin.load! }.should_not raise_error
+          end
+        end
+
+        it "should fail gracefully" do
+          stderr = capture_stderr do
+            Plugin.load!
+          end
+          stderr.should include('some_non_existant_file (LoadError)')
+        end
+
+        it "should still load other plugins" do
+          FileUtils.mkdir_p(@sandbox + '/some_plugin_2/lib')
+          File.open(@sandbox + '/some_plugin_2/init.rb', 'w') { |f| f.write "LoadedPlugin2 = true" }
+          stderr = capture_stderr do
+            Plugin.load!
+          end
+          stderr.should include('some_non_existant_file (LoadError)')
+          LoadedPlugin2.should be_true
+        end
+      end
+
+      describe "deprecated plugins" do
+        before(:each) do
+          FileUtils.mkdir_p(@sandbox + '/azuki-releases/lib')
+        end
+
+        after(:each) do
+          FileUtils.rm_rf(@sandbox + '/azuki-releases/lib')
+        end
+
+        it "should show confirmation to remove deprecated plugins if in an interactive shell" do
+          old_stdin_isatty = STDIN.isatty
+          STDIN.stub!(:isatty).and_return(true)
+          Plugin.should_receive(:confirm).with("The plugin azuki-releases has been deprecated. Would you like to remove it? (y/N)").and_return(true)
+          Plugin.should_receive(:remove_plugin).with("azuki-releases")
+          Plugin.load!
+          STDIN.stub!(:isatty).and_return(old_stdin_isatty)
+        end
+
+        it "should not prompt for deprecation if not in an interactive shell" do
+          old_stdin_isatty = STDIN.isatty
+          STDIN.stub!(:isatty).and_return(false)
+          Plugin.should_not_receive(:confirm)
+          Plugin.should_not_receive(:remove_plugin).with("azuki-releases")
+          Plugin.load!
+          STDIN.stub!(:isatty).and_return(old_stdin_isatty)
+        end
+      end
+    end
+  end
+end

data/spec/azuki/updater_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "azuki/updater"
+require "azuki/version"
+
+module Azuki
+  describe Updater do
+
+    it "calculates the latest local version" do
+      Azuki::Updater.latest_local_version.should == Azuki::VERSION
+    end
+
+    it "calculates compare_versions" do
+      Azuki::Updater.compare_versions('1.1.1', '1.1.1').should == 0
+
+      Azuki::Updater.compare_versions('2.1.1', '1.1.1').should == 1
+      Azuki::Updater.compare_versions('1.1.1', '2.1.1').should == -1
+
+      Azuki::Updater.compare_versions('1.2.1', '1.1.1').should == 1
+      Azuki::Updater.compare_versions('1.1.1', '1.2.1').should == -1
+
+      Azuki::Updater.compare_versions('1.1.2', '1.1.1').should == 1
+      Azuki::Updater.compare_versions('1.1.1', '1.1.2').should == -1
+
+      Azuki::Updater.compare_versions('2.1.1', '1.2.1').should == 1
+      Azuki::Updater.compare_versions('1.2.1', '2.1.1').should == -1
+
+      Azuki::Updater.compare_versions('2.1.1', '1.1.2').should == 1
+      Azuki::Updater.compare_versions('1.1.2', '2.1.1').should == -1
+
+      Azuki::Updater.compare_versions('1.2.4', '1.2.3').should == 1
+      Azuki::Updater.compare_versions('1.2.3', '1.2.4').should == -1
+
+      Azuki::Updater.compare_versions('1.2.1', '1.2'  ).should == 1
+      Azuki::Updater.compare_versions('1.2',   '1.2.1').should == -1
+
+      Azuki::Updater.compare_versions('1.1.1.pre1', '1.1.1').should == 1
+      Azuki::Updater.compare_versions('1.1.1', '1.1.1.pre1').should == -1
+
+      Azuki::Updater.compare_versions('1.1.1.pre2', '1.1.1.pre1').should == 1
+      Azuki::Updater.compare_versions('1.1.1.pre1', '1.1.1.pre2').should == -1
+    end
+
+  end
+end

data/spec/helper/legacy_help.rb

@@ -0,0 +1,16 @@
+require "azuki/command/help"
+
+Azuki::Command::Help.group("Foo Group") do |foo|
+  foo.command "foo:bar", "do a bar to foo"
+  foo.space
+  foo.command "foo:baz", "do a baz to foo"
+end
+
+class Azuki::Command::Foo < Azuki::Command::Base
+  def bar
+  end
+
+  def baz
+  end
+end
+

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,224 @@
+$stdin = File.new("/dev/null")
+
+require "rubygems"
+
+require "excon"
+Excon.defaults[:mock] = true
+
+# ensure these are around for errors
+# as their require is generally deferred
+require "azuki-api"
+require "rest_client"
+
+require "azuki/cli"
+require "rspec"
+require "rr"
+require "fakefs/safe"
+require 'tmpdir'
+require "webmock/rspec"
+
+include WebMock::API
+
+WebMock::HttpLibAdapters::ExconAdapter.disable!
+
+def api
+  Azuki::API.new(:api_key => "pass", :mock => true)
+end
+
+def stub_api_request(method, path)
+  stub_request(method, "https://api.azukiapp.com#{path}")
+end
+
+def prepare_command(klass)
+  command = klass.new
+  command.stub!(:app).and_return("example")
+  command.stub!(:ask).and_return("")
+  command.stub!(:display)
+  command.stub!(:hputs)
+  command.stub!(:hprint)
+  command.stub!(:azuki).and_return(mock('azuki client', :host => 'azukiapp.com'))
+  command
+end
+
+def execute(command_line)
+  extend RR::Adapters::RRMethods
+
+  args = command_line.split(" ")
+  command = args.shift
+
+  Azuki::Command.load
+  object, method = Azuki::Command.prepare_run(command, args)
+
+  any_instance_of(Azuki::Command::Base) do |base|
+    stub(base).app.returns("example")
+  end
+
+  stub(Azuki::Auth).get_credentials.returns(['email@example.com', 'apikey01'])
+  stub(Azuki::Auth).api_key.returns('apikey01')
+
+  original_stdin, original_stderr, original_stdout = $stdin, $stderr, $stdout
+
+  $stdin  = captured_stdin  = StringIO.new
+  $stderr = captured_stderr = StringIO.new
+  $stdout = captured_stdout = StringIO.new
+  class << captured_stdout
+    def tty?
+      true
+    end
+  end
+
+  begin
+    object.send(method)
+  rescue SystemExit
+  ensure
+    $stdin, $stderr, $stdout = original_stdin, original_stderr, original_stdout
+    Azuki::Command.current_command = nil
+  end
+
+  [captured_stderr.string, captured_stdout.string]
+end
+
+def any_instance_of(klass, &block)
+  extend RR::Adapters::RRMethods
+  any_instance_of(klass, &block)
+end
+
+def run(command_line)
+  capture_stdout do
+    begin
+      Azuki::CLI.start(*command_line.split(" "))
+    rescue SystemExit
+    end
+  end
+end
+
+alias azuki run
+
+def capture_stderr(&block)
+  original_stderr = $stderr
+  $stderr = captured_stderr = StringIO.new
+  begin
+    yield
+  ensure
+    $stderr = original_stderr
+  end
+  captured_stderr.string
+end
+
+def capture_stdout(&block)
+  original_stdout = $stdout
+  $stdout = captured_stdout = StringIO.new
+  begin
+    yield
+  ensure
+    $stdout = original_stdout
+  end
+  captured_stdout.string
+end
+
+def fail_command(message)
+  raise_error(Azuki::Command::CommandFailed, message)
+end
+
+def stub_core
+  @stubbed_core ||= begin
+    stubbed_core = nil
+    any_instance_of(Azuki::Client) do |core|
+      stubbed_core = stub(core)
+    end
+    stub(Azuki::Auth).user.returns("email@example.com")
+    stub(Azuki::Auth).password.returns("pass")
+    stub(Azuki::Client).auth.returns("apikey01")
+    stubbed_core
+  end
+end
+
+def stub_pg
+  @stubbed_pg ||= begin
+    stubbed_pg = nil
+    any_instance_of(Azuki::Client::AzukiPostgresql) do |pg|
+      stubbed_pg = stub(pg)
+    end
+    stubbed_pg
+  end
+end
+
+def stub_pgbackups
+  @stubbed_pgbackups ||= begin
+    stubbed_pgbackups = nil
+    any_instance_of(Azuki::Client::Pgbackups) do |pgbackups|
+      stubbed_pgbackups = stub(pgbackups)
+    end
+    stubbed_pgbackups
+  end
+end
+
+def stub_rendezvous
+  @stubbed_rendezvous ||= begin
+    stubbed_rendezvous = nil
+    any_instance_of(Azuki::Client::Rendezvous) do |rendezvous|
+      stubbed_rendezvous = stub(rendezvous)
+    end
+    stubbed_rendezvous
+  end
+end
+
+def stub_cisaurus
+  @stub_cisaurus ||= begin
+    stub_cisaurus = nil
+    any_instance_of(Azuki::Client::Cisaurus) do |cisaurus|
+      stub_cisaurus = stub(cisaurus)
+    end
+    stub_cisaurus
+  end
+end
+
+def with_blank_git_repository(&block)
+  sandbox = File.join(Dir.tmpdir, "azuki", Process.pid.to_s)
+  FileUtils.mkdir_p(sandbox)
+
+  old_dir = Dir.pwd
+  Dir.chdir(sandbox)
+
+  `git init`
+  block.call
+
+  FileUtils.rm_rf(sandbox)
+ensure
+  Dir.chdir(old_dir)
+end
+
+def taps_available?
+  begin
+    require "taps/operation"
+    true
+  rescue LoadError
+    false
+  end
+end
+
+module SandboxHelper
+  def bash(cmd)
+    `#{cmd}`
+  end
+end
+
+require "azuki/helpers"
+module Azuki::Helpers
+  @home_directory = Dir.mktmpdir
+  undef_method :home_directory
+  def home_directory
+    @home_directory
+  end
+end
+
+require "support/display_message_matcher"
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.include DisplayMessageMatcher
+  config.order = 'rand'
+  config.before { Azuki::Helpers.error_with_failure = false }
+  config.after { RR.reset }
+end
+