azuki 0.0.1

data/spec/azuki/auth_spec.rb

@@ -0,0 +1,256 @@
+require "spec_helper"
+require "azuki/auth"
+require "azuki/helpers"
+
+module Azuki
+  describe Auth do
+    include Azuki::Helpers
+
+    before do
+      ENV['AZUKI_API_KEY'] = nil
+
+      @cli = Azuki::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.azukiapp.com\n  login user\n  password pass\n")
+        file.puts("machine code.azukiapp.com\n  login user\n  password pass\n")
+      end
+    end
+
+    after do
+      FileUtils.rm_rf(@cli.netrc_path)
+      FakeFS.deactivate!
+    end
+
+    context "legacy credentials" do
+
+      before do
+        FileUtils.rm_rf(@cli.netrc_path)
+        FileUtils.mkdir_p(File.dirname(@cli.legacy_credentials_path))
+        File.open(@cli.legacy_credentials_path, "w") do |file|
+          file.puts "legacy_user\nlegacy_pass"
+        end
+      end
+
+      it "should translate to netrc and cleanup" do
+        # preconditions
+        File.exist?(@cli.legacy_credentials_path).should == true
+        File.exist?(@cli.netrc_path).should == false
+
+        # transition
+        @cli.get_credentials.should == ['legacy_user', 'legacy_pass']
+
+        # postconditions
+        File.exist?(@cli.legacy_credentials_path).should == false
+        File.exist?(@cli.netrc_path).should == true
+        Netrc.read(@cli.netrc_path)["api.#{@cli.host}"].should == ['legacy_user', 'legacy_pass']
+      end
+    end
+
+    context "API key is set via environment variable" do
+      before do
+        ENV['AZUKI_API_KEY'] = "secret"
+      end
+
+      it "gets credentials from environment variables in preference to credentials file" do
+        @cli.read_credentials.should == ['', ENV['AZUKI_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['AZUKI_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['AZUKI_API_KEY']]
+        end
+      end
+
+      context "logout" do
+        before do
+          @cli.logout
+        end
+        it "should delete saved credentials" do
+          File.exists?(@cli.legacy_credentials_path).should be_false
+          Netrc.read(@cli.netrc_path)["api.#{@cli.host}"].should be_nil
+        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 Azuki::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 Azuki::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 "deletes the credentials file" do
+      FileUtils.mkdir_p(File.dirname(@cli.legacy_credentials_path))
+      File.open(@cli.legacy_credentials_path, "w") do |file|
+        file.puts "legacy_user\nlegacy_pass"
+      end
+      FileUtils.should_receive(:rm_f).with(@cli.legacy_credentials_path)
+      @cli.delete_credentials
+    end
+
+    it "writes the login information to the credentials file for the 'azuki 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_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_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/azuki/client/azuki_postgresql_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+require "azuki/client/azuki_postgresql"
+require "digest"
+
+describe Azuki::Client::AzukiPostgresql do
+  include Azuki::Helpers
+
+  before do
+    Azuki::Auth.stub :user => 'user@example.com', :password => 'apitoken'
+  end
+
+  let(:attachment) { double('attachment', :resource_name => 'something-something-42', :starter_plan? => false) }
+  let(:client)  { Azuki::Client::AzukiPostgresql.new(attachment) }
+
+  describe 'api choosing' do
+    it "sends an ingress request to the client for production plans" do
+      attachment.stub! :starter_plan? => false
+      host = 'postgres-api.azukiapp.com'
+      url  = "https://user@example.com:apitoken@#{host}/client/v11/databases/#{attachment.resource_name}/ingress"
+
+      stub_request(:put, url).to_return(
+        :body => json_encode({"message" => "ok"}),
+        :status => 200
+      )
+
+      client.ingress
+
+      a_request(:put, url).should have_been_made.once
+    end
+
+    it "sends an ingress request to the client for production plans" do
+      attachment.stub! :starter_plan? => true
+      host = 'postgres-starter-api.azukiapp.com'
+      url  = "https://user@example.com:apitoken@#{host}/client/v11/databases/#{attachment.resource_name}/ingress"
+
+      stub_request(:put, url).to_return(
+        :body => json_encode({"message" => "ok"}),
+        :status => 200
+      )
+
+      client.ingress
+
+      a_request(:put, url).should have_been_made.once
+    end
+  end
+
+  describe '#get_database' do
+    let(:url) { "https://user@example.com:apitoken@postgres-api.azukiapp.com/client/v11/databases/#{attachment.resource_name}" }
+
+    it 'works without the extended option' do
+      stub_request(:get, url).to_return :body => '{}'
+      client.get_database
+      a_request(:get, url).should have_been_made.once
+    end
+
+    it 'works with the extended option' do
+      url2 = url + '?extended=true'
+      stub_request(:get, url2).to_return :body => '{}'
+      client.get_database(true)
+      a_request(:get, url2).should have_been_made.once
+    end
+
+    it "retries on error, then raises" do
+      stub_request(:get, url).to_return(:body => "error", :status => 500)
+      client.stub(:sleep)
+      lambda { client.get_database }.should raise_error RestClient::InternalServerError
+      a_request(:get, url).should have_been_made.times(4)
+    end
+  end
+
+end

data/spec/azuki/client/pgbackups_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "azuki/client/pgbackups"
+require "azuki/helpers"
+
+describe Azuki::Client::Pgbackups do
+
+  include Azuki::Helpers
+
+  let(:path)   { "http://id:password@pgbackups.azukiapp.com" }
+  let(:client) { Azuki::Client::Pgbackups.new path+'/api' }
+  let(:transfer_path) { path + '/client/transfers' }
+
+  describe "api" do
+    let(:version) { Azuki::Client.version }
+
+    it 'still has a azuki gem version' do
+      version.should be
+      version.split(/\./).first.to_i.should >= 2
+    end
+
+    it 'includes the azuki gem version' do
+      stub_request(:get, transfer_path)
+      client.get_transfers
+      a_request(:get, transfer_path).with(
+        :headers => {'X-Azuki-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

data/spec/azuki/client/rendezvous_spec.rb

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+require "spec_helper"
+require "azuki/client/rendezvous"
+require "support/openssl_mock_helper"
+
+describe Azuki::Client, "rendezvous" do
+  before do
+    @rendezvous = Azuki::Client::Rendezvous.new({
+      :rendezvous_url => "https://azuki.local:1234/secret",
+      :output => $stdout
+    })
+  end
+  context "fixup" do
+    it "null" do
+      @rendezvous.send(:fixup, nil).should be_nil
+    end
+    it "an empty string" do
+      @rendezvous.send(:fixup, "").should eq ""
+    end
+    it "hash" do
+      @rendezvous.send(:fixup, { :x => :y }).should eq({ :x => :y })
+    end
+    it "default English UTF-8 data" do
+      @rendezvous.send(:fixup, "azuki").should eq "azuki"
+    end
+    it "default Japanese UTF-8 encoded data" do
+      @rendezvous.send(:fixup, "愛しています").should eq "愛しています"
+    end
+    if RUBY_VERSION >= "1.9"
+      it "ISO-8859-1 force-encoded data" do
+        @rendezvous.send(:fixup, "Хероку".force_encoding("ISO-8859-1")).should eq "Хероку".force_encoding("UTF-8")
+      end
+    end
+  end
+  context "with mock ssl" do
+    before :each do
+      mock_openssl
+      @ssl_socket_mock.should_receive(:puts).with("secret")
+      @ssl_socket_mock.should_receive(:readline).and_return(nil)
+    end
+    it "should connect to host:post" do
+      TCPSocket.should_receive(:open).with("azuki.local", 1234).and_return(@tcp_socket_mock)
+      IO.stub(:select).and_return(nil)
+      @ssl_socket_mock.stub(:write)
+      @ssl_socket_mock.stub(:flush) { raise Timeout::Error }
+      lambda { @rendezvous.start }.should raise_error(Timeout::Error)
+    end
+    it "should callback on_connect" do
+      @rendezvous.on_connect do 
+        raise "on_connect"
+      end
+      TCPSocket.should_receive(:open).and_return(@tcp_socket_mock)
+      lambda { @rendezvous.start }.should raise_error("on_connect")
+    end
+    it "should fixup received data" do
+      TCPSocket.should_receive(:open).and_return(@tcp_socket_mock)
+      @ssl_socket_mock.should_receive(:readpartial).and_return("The quick brown fox jumps over the lazy dog")
+      @rendezvous.stub(:fixup) { |data| raise "received: #{data}" }
+      lambda { @rendezvous.start }.should raise_error("received: The quick brown fox jumps over the lazy dog")
+    end
+  end
+end

data/spec/azuki/client/ssl_endpoint_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "azuki/client/ssl_endpoint"
+
+describe Azuki::Client, "ssl endpoints" do
+  before do
+    @client = Azuki::Client.new(nil, nil)
+  end
+
+  it "adds an ssl endpoint" do
+    stub_request(:post, "https://api.azukiapp.com/apps/example/ssl-endpoints").
+      with(:body => { :accept => "json", :pem => "pem content", :key => "key content" }).
+      to_return(:body => %{ {"cname": "tokyo-1050" } })
+    @client.ssl_endpoint_add("example", "pem content", "key content").should == { "cname" => "tokyo-1050" }
+  end
+
+  it "gets info on an ssl endpoint" do
+    stub_request(:get, "https://api.azukiapp.com/apps/example/ssl-endpoints/tokyo-1050").
+      to_return(:body => %{ {"cname": "tokyo-1050" } })
+    @client.ssl_endpoint_info("example", "tokyo-1050").should == { "cname" => "tokyo-1050" }
+  end
+
+  it "lists ssl endpoints for an app" do
+    stub_request(:get, "https://api.azukiapp.com/apps/example/ssl-endpoints").
+      to_return(:body => %{ [{"cname": "tokyo-1050" }, {"cname": "tokyo-1051" }] })
+    @client.ssl_endpoint_list("example").should == [
+      { "cname" => "tokyo-1050" },
+      { "cname" => "tokyo-1051" },
+    ]
+  end
+
+  it "removes an ssl endpoint" do
+    stub_request(:delete, "https://api.azukiapp.com/apps/example/ssl-endpoints/tokyo-1050")
+    @client.ssl_endpoint_remove("example", "tokyo-1050")
+  end
+
+  it "rolls back an ssl endpoint" do
+    stub_request(:post, "https://api.azukiapp.com/apps/example/ssl-endpoints/tokyo-1050/rollback").
+      to_return(:body => %{ {"cname": "tokyo-1050" } })
+    @client.ssl_endpoint_rollback("example", "tokyo-1050").should == { "cname" => "tokyo-1050" }
+  end
+
+  it "updates an ssl endpoint" do
+    stub_request(:put, "https://api.azukiapp.com/apps/example/ssl-endpoints/tokyo-1050").
+      with(:body => { :accept => "json", :pem => "pem content", :key => "key content" }).
+      to_return(:body => %{ {"cname": "tokyo-1050" } })
+    @client.ssl_endpoint_update("example", "tokyo-1050", "pem content", "key content").should == { "cname" => "tokyo-1050" }
+  end
+end