turbot 0.0.2

data/spec/spec_helper.rb

@@ -0,0 +1,220 @@
+$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 "turbot-api"
+require "rest_client"
+
+require "turbot/cli"
+require "rspec"
+require "rr"
+require "fakefs/safe"
+require 'tmpdir'
+require "webmock/rspec"
+
+include WebMock::API
+
+WebMock::HttpLibAdapters::ExconAdapter.disable!
+
+def api
+  Turbot::API.new(:api_key => "pass", :mock => true)
+end
+
+def org_api
+  Turbot::Client::Organizations.api(:mock => true)
+end
+
+def stub_api_request(method, path)
+  stub_request(method, "https://api.turbot.com#{path}")
+end
+
+def prepare_command(klass)
+  command = klass.new
+  command.stub!(:bot).and_return("example")
+  command.stub!(:ask).and_return("")
+  command.stub!(:display)
+  command.stub!(:hputs)
+  command.stub!(:hprint)
+  command.stub!(:turbot).and_return(mock('turbot client', :host => 'turbot.com'))
+  command
+end
+
+def execute(command_line)
+  extend RR::Adapters::RRMethods
+
+  args = command_line.split(" ")
+  command = args.shift
+
+  Turbot::Command.load
+  object, method = Turbot::Command.prepare_run(command, args)
+
+  any_instance_of(Turbot::Command::Base) do |base|
+    stub(base).bot.returns("example")
+  end
+
+  stub(Turbot::Auth).get_credentials.returns(['email@example.com', 'apikey01'])
+  stub(Turbot::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
+    Turbot::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
+      Turbot::CLI.start(*command_line.split(" "))
+    rescue SystemExit
+    end
+  end
+end
+
+alias turbot 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(Turbot::Command::CommandFailed, message)
+end
+
+def stub_core
+  @stubbed_core ||= begin
+    stubbed_core = nil
+    any_instance_of(Turbot::Client) do |core|
+      stubbed_core = stub(core)
+    end
+    stub(Turbot::Auth).user.returns("email@example.com")
+    stub(Turbot::Auth).password.returns("pass")
+    stub(Turbot::Client).auth.returns("apikey01")
+    stubbed_core
+  end
+end
+
+def stub_pg
+  @stubbed_pg ||= begin
+    stubbed_pg = nil
+    any_instance_of(Turbot::Client::TurbotPostgresql) do |pg|
+      stubbed_pg = stub(pg)
+    end
+    stubbed_pg
+  end
+end
+
+def stub_pgbackups
+  @stubbed_pgbackups ||= begin
+    stubbed_pgbackups = nil
+    any_instance_of(Turbot::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(Turbot::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(Turbot::Client::Cisaurus) do |cisaurus|
+      stub_cisaurus = stub(cisaurus)
+    end
+    stub_cisaurus
+  end
+end
+
+def with_blank_git_repository(&block)
+  sandbox = File.join(Dir.tmpdir, "turbot", 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
+
+module SandboxHelper
+  def bash(cmd)
+    `#{cmd}`
+  end
+end
+
+require "turbot/helpers"
+module Turbot::Helpers
+  @home_directory = Dir.mktmpdir
+  undef_method :home_directory
+  def home_directory
+    @home_directory
+  end
+end
+
+require "support/display_message_matcher"
+require "support/organizations_mock_helper"
+require "support/dummy_api"
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.include DisplayMessageMatcher
+  config.order = 'rand'
+  config.before { Turbot::Helpers.error_with_failure = false }
+  config.after { RR.reset }
+end

data/spec/support/display_message_matcher.rb

@@ -0,0 +1,49 @@
+module DisplayMessageMatcher
+
+  def display_message(command, message)
+    DisplayMessageMatcher::DisplayMessage.new command, message
+  end
+
+  class DisplayMessage
+    def initialize(command, message)
+      @command = command
+      @message = message
+    end
+
+    def matches?(given_proc)
+      displayed_expected_message = false
+      @given_messages = []
+
+      @command.should_receive(:display).
+        any_number_of_times do |message, newline|
+        @given_messages << message
+        displayed_expected_message = displayed_expected_message ||
+          message == @message
+      end
+
+      given_proc.call
+
+      displayed_expected_message
+    end
+
+    def failure_message
+      "expected #{ @command } to display the message #{ @message.inspect } but #{ given_messages }"
+    end
+
+    def negative_failure_message
+      "expected #{ @command } to not display the message #{ @message.inspect } but it was displayed"
+    end
+
+    private
+
+      def given_messages
+        if @given_messages.empty?
+          'no messages were displayed'
+        else
+          formatted_given_messages = @given_messages.map(&:inspect).join ', '
+          "the follow messages were displayed: #{ formatted_given_messages }"
+        end
+      end
+
+  end
+end

data/spec/support/dummy_api.rb

@@ -0,0 +1,120 @@
+require 'json'
+
+module Turbot
+  class API
+    def initialize(params)
+      @headers = params[:headers]
+      @host = params[:host]
+      @port = params[:port]
+      @username = params[:username]
+      @password = params[:password]
+      @scheme = params[:scheme]
+      @ssl_verify_peer = params[:ssl_verify_peer]
+      @api_key = params[:api_key] || get_api_key(@username, @password)
+      authenticate
+
+    end
+
+    def authenticate
+      # Try to authenticate at this stage - something like
+      #user_pass = ":#{@api_key}"
+      #options[:headers] = HEADERS.merge({
+      #  'Authorization' => "Basic #{Base64.encode64(user_pass).gsub("\n", '')}",
+      # }).merge(options[:headers])
+
+      # @connection = Excon.new("http://missions.opencorporates.com/login", options)
+
+    end
+
+    def get_user
+      # raise if not authenticated
+      # @connection.code < 400
+    end
+
+    def get_api_key(user, password)
+      # get the api key, raise exception if credentials broken
+      # this is a hash of the username and password plus salt
+      return "some-api-key"
+    end
+
+    def get_keys
+      # return an array of ssh keys
+      read_db("keys")
+    end
+
+    def post_key(key)
+      # receive ssh key and associate with account
+      append_db("keys", {"contents" => key})
+    end
+
+    def delete_key(key)
+      keys = read_db("keys")
+      keys.delete(key)
+      write_db("keys", keys)
+    end
+
+    def delete_keys
+      write_db("keys", [])
+    end
+
+    def post_bot(data)
+      # XXX need to implement this to make the config command pass...
+      # save an "bot" - we'll replace this with the bot stuff chris did
+      db = read_db("bot")
+      db[data["name"]] = data
+      write_db("bot", db)
+    end
+
+    def delete_bot(bot)
+      db = read_db("bot")
+      db.delete(bot)
+      write_db("bot", db)
+    end
+
+    def get_bots
+      read_db("bot", [])
+    end
+
+    def get_bot(bot)
+      db = read_db("bot_data", [])
+      db[bot]
+    end
+
+    def put_config_vars(bot, vars)
+      # Set vars for bot specified
+      config = read_db("config")
+      config[bot] = vars
+      write_db("config", config)
+    end
+
+    def get_config_vars(bot)
+      read_db("config", [])[bot]
+    end
+
+    def delete_config_var(bot, key)
+      db = read_db("config", [])
+      keys = db[bot]
+      keys.delete(key)
+      db[bot] = keys
+      write_db("config", db)
+    end
+
+    private
+
+    def write_db(name, data)
+      open("/tmp/#{name}", "w") do |f|
+        f.write(JSON.dump(data))
+      end
+    end
+
+    def read_db(name, default={})
+      JSON.parse(open("/tmp/#{name}", "r").read) rescue {}
+    end
+
+    def append_db(name, data)
+      db = read_db(name, [])
+      db << data
+      write_db(name, db)
+    end
+  end
+end

data/spec/support/openssl_mock_helper.rb

@@ -0,0 +1,8 @@
+def mock_openssl
+  @ctx_mock        = mock "SSLContext", :key= => nil, :cert= => nil, :ssl_version= => nil
+  @tcp_socket_mock = mock "TCPSocket", :close => true
+  @ssl_socket_mock = mock "SSLSocket", :sync= => true, :connect => true, :close => true, :to_io => $stdin
+  
+  OpenSSL::SSL::SSLSocket.stub(:new).and_return(@ssl_socket_mock)
+  OpenSSL::SSL::SSLContext.stub(:new).and_return(@ctx_mock)
+end

data/spec/support/organizations_mock_helper.rb

@@ -0,0 +1,11 @@
+class Turbot::Client::Organizations
+
+  # stub GET /v1/user/info
+  Excon.stub(:expects => 200, :method => :get, :path => %r{^/v1/user/info$} ) do |params|
+    {
+      :body => "",
+      :status => 404
+    }
+  end
+
+end

data/spec/turbot/auth_spec.rb

@@ -0,0 +1,214 @@
+require "spec_helper"
+require "turbot/auth"
+require "turbot/helpers"
+
+module Turbot
+  describe Auth do
+    include Turbot::Helpers
+
+    before do
+      ENV['TURBOT_API_KEY'] = nil
+
+      @cli = Turbot::Auth
+      @cli.stub!(:check)
+      @cli.stub!(:display)
+      @cli.stub!(:running_on_a_mac?).and_return(false)
+      @cli.credentials = nil
+
+      FakeFS.activate!
+
+      FakeFS::File.stub!(:stat).and_return(double('stat', :mode => "0600".to_i(8)))
+      FakeFS::FileUtils.stub!(:chmod)
+      FakeFS::File.stub!(:readlines) do |path|
+        File.read(path).split("\n").map {|line| "#{line}\n"}
+      end
+
+      FileUtils.mkdir_p(@cli.netrc_path.split("/")[0..-2].join("/"))
+
+      File.open(@cli.netrc_path, "w") do |file|
+        file.puts("machine api.turbot.com\n  login user\n  password pass\n")
+        file.puts("machine code.turbot.com\n  login user\n  password pass\n")
+      end
+    end
+
+    after do
+      FileUtils.rm_rf(@cli.netrc_path)
+      FakeFS.deactivate!
+    end
+
+
+    context "API key is set via environment variable" do
+      before do
+        ENV['TURBOT_API_KEY'] = "secret"
+      end
+
+      it "gets credentials from environment variables in preference to credentials file" do
+        @cli.read_credentials.should == ['', ENV['TURBOT_API_KEY']]
+      end
+
+      it "returns a blank username" do
+        @cli.user.should be_empty
+      end
+
+      it "returns the api key as the password" do
+        @cli.password.should == ENV['TURBOT_API_KEY']
+      end
+
+      it "does not overwrite credentials file with environment variable credentials" do
+        @cli.should_not_receive(:write_credentials)
+        @cli.read_credentials
+      end
+
+      context "reauthenticating" do
+        before do
+          @cli.stub!(:ask_for_credentials).and_return(['new_user', 'new_password'])
+          @cli.stub!(:check)
+          @cli.should_receive(:check_for_associated_ssh_key)
+          @cli.reauthorize
+        end
+        it "updates saved credentials" do
+          Netrc.read(@cli.netrc_path)["api.#{@cli.host}"].should == ['new_user', 'new_password']
+        end
+        it "returns environment variable credentials" do
+          @cli.read_credentials.should == ['', ENV['TURBOT_API_KEY']]
+        end
+      end
+
+    end
+
+    describe "#base_host" do
+      it "returns the host without the first part" do
+        @cli.base_host("http://foo.bar.com").should == "bar.com"
+      end
+
+      it "works with localhost" do
+        @cli.base_host("http://localhost:3000").should == "localhost"
+      end
+    end
+
+    it "asks for credentials when the file doesn't exist" do
+      @cli.delete_credentials
+      @cli.should_receive(:ask_for_credentials).and_return(["u", "p"])
+      @cli.should_receive(:check_for_associated_ssh_key)
+      @cli.user.should == 'u'
+      @cli.password.should == 'p'
+    end
+
+    it "writes credentials and uploads authkey when credentials are saved" do
+      @cli.stub!(:credentials)
+      @cli.stub!(:check)
+      @cli.stub!(:ask_for_credentials).and_return("username", "apikey")
+      @cli.should_receive(:write_credentials)
+      @cli.should_receive(:check_for_associated_ssh_key)
+      @cli.ask_for_and_save_credentials
+    end
+
+    it "save_credentials deletes the credentials when the upload authkey is unauthorized" do
+      @cli.stub!(:write_credentials)
+      @cli.stub!(:retry_login?).and_return(false)
+      @cli.stub!(:ask_for_credentials).and_return("username", "apikey")
+      @cli.stub!(:check) { raise Turbot::API::Errors::Unauthorized.new("Login Failed", Excon::Response.new) }
+      @cli.should_receive(:delete_credentials)
+      lambda { @cli.ask_for_and_save_credentials }.should raise_error(SystemExit)
+    end
+
+    it "asks for login again when not authorized, for three times" do
+      @cli.stub!(:read_credentials)
+      @cli.stub!(:write_credentials)
+      @cli.stub!(:delete_credentials)
+      @cli.stub!(:ask_for_credentials).and_return("username", "apikey")
+      @cli.stub!(:check) { raise Turbot::API::Errors::Unauthorized.new("Login Failed", Excon::Response.new) }
+      @cli.should_receive(:ask_for_credentials).exactly(3).times
+      lambda { @cli.ask_for_and_save_credentials }.should raise_error(SystemExit)
+    end
+
+    it "writes the login information to the credentials file for the 'turbot login' command" do
+      @cli.stub!(:ask_for_credentials).and_return(['one', 'two'])
+      @cli.stub!(:check)
+      @cli.should_receive(:check_for_associated_ssh_key)
+      @cli.reauthorize
+      Netrc.read(@cli.netrc_path)["api.#{@cli.host}"].should == (['one', 'two'])
+    end
+
+    it "migrates long api keys to short api keys" do
+      @cli.delete_credentials
+      api_key = "7e262de8cac430d8a250793ce8d5b334ae56b4ff15767385121145198a2b4d2e195905ef8bf7cfc5"
+      @cli.netrc["api.#{@cli.host}"] = ["user", api_key]
+
+      @cli.get_credentials.should == ["user", api_key[0,40]]
+      %w{api code}.each do |section|
+        Netrc.read(@cli.netrc_path)["#{section}.#{@cli.host}"].should == ["user", api_key[0,40]]
+      end
+    end
+
+    describe "automatic key uploading" do
+      before(:each) do
+        FileUtils.mkdir_p("#{@cli.home_directory}/.ssh")
+        @cli.stub!(:ask_for_credentials).and_return("username", "apikey")
+      end
+
+      describe "an account with existing keys" do
+        before :each do
+          @api = mock(Object)
+          @response = mock(Object)
+          @response.should_receive(:body).and_return(['existingkeys'])
+          @api.should_receive(:get_ssh_keys).and_return(@response)
+          @cli.should_receive(:api).and_return(@api)
+        end
+
+        it "should not do anything if the account already has keys" do
+          @cli.should_not_receive(:associate_key)
+          @cli.check_for_associated_ssh_key
+        end
+      end
+
+      describe "an account with no keys" do
+        before :each do
+          @api = mock(Object)
+          @response = mock(Object)
+          @response.should_receive(:body).and_return([])
+          @api.should_receive(:get_ssh_keys).and_return(@response)
+          @cli.should_receive(:api).and_return(@api)
+        end
+
+        describe "with zero public keys" do
+          it "should ask to generate a key" do
+            @cli.should_receive(:ask).and_return("y")
+            @cli.should_receive(:generate_ssh_key).with("id_rsa")
+            @cli.should_receive(:associate_key).with("#{@cli.home_directory}/.ssh/id_rsa.pub")
+            @cli.check_for_associated_ssh_key
+          end
+        end
+
+        describe "with one public key" do
+          before(:each) { FileUtils.touch("#{@cli.home_directory}/.ssh/id_rsa.pub") }
+          after(:each)  { FileUtils.rm("#{@cli.home_directory}/.ssh/id_rsa.pub") }
+
+          it "should upload the key" do
+            @cli.should_receive(:associate_key).with("#{@cli.home_directory}/.ssh/id_rsa.pub")
+            @cli.check_for_associated_ssh_key
+          end
+        end
+
+        describe "with many public keys" do
+          before(:each) do
+            FileUtils.touch("#{@cli.home_directory}/.ssh/id_rsa.pub")
+            FileUtils.touch("#{@cli.home_directory}/.ssh/id_rsa2.pub")
+          end
+
+          after(:each) do
+            FileUtils.rm("#{@cli.home_directory}/.ssh/id_rsa.pub")
+            FileUtils.rm("#{@cli.home_directory}/.ssh/id_rsa2.pub")
+          end
+
+          it "should ask which key to upload" do
+            File.open("#{@cli.home_directory}/.ssh/id_rsa.pub", "w") { |f| f.puts }
+            @cli.should_receive(:associate_key).with("#{@cli.home_directory}/.ssh/id_rsa2.pub")
+            @cli.should_receive(:ask).and_return("2")
+            @cli.check_for_associated_ssh_key
+          end
+        end
+      end
+    end
+  end
+end

data/spec/turbot/client/pgbackups_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "turbot/client/pgbackups"
+require "turbot/helpers"
+
+describe Turbot::Client::Pgbackups do
+
+  include Turbot::Helpers
+
+  let(:path)   { "http://id:password@pgbackups.turbot.com" }
+  let(:client) { Turbot::Client::Pgbackups.new path+'/api' }
+  let(:transfer_path) { path + '/client/transfers' }
+
+  describe "api" do
+    let(:version) { Turbot::Client.version }
+
+    it 'still has a turbot gem version' do
+      version.should be
+      version.split(/\./).first.to_i.should >= 0
+    end
+
+    it 'includes the turbot gem version' do
+      stub_request(:get, transfer_path)
+      client.get_transfers
+      a_request(:get, transfer_path).with(
+        :headers => {'X-Turbot-Gem-Version' => version}
+      ).should have_been_made.once
+    end
+  end
+
+  describe "create transfers" do
+    it "sends a request to the client" do
+      stub_request(:post, transfer_path).to_return(
+        :body => json_encode({"message" => "success"}),
+        :status => 200
+      )
+
+      client.create_transfer("postgres://from", "postgres://to", "FROMNAME", "TO_NAME")
+
+      a_request(:post, transfer_path).should have_been_made.once
+    end
+  end
+
+end