azuki-api 0.0.2

data/test/test_config_vars.rb

@@ -0,0 +1,54 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+class TestConfigVars < MiniTest::Unit::TestCase
+
+  def test_delete_app_config_var
+    with_app('stack' => 'cedar') do |app_data|
+      azuki.put_config_vars(app_data['name'], {'KEY' => 'value'})
+
+      response = azuki.delete_config_var(app_data['name'], 'KEY')
+
+      assert_equal(200, response.status)
+      assert_equal({}, response.body)
+    end
+  end
+
+  def test_delete_app_config_var_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.delete_config_var(random_name, 'key')
+    end
+  end
+
+  def test_get_app_config_vars
+    with_app('stack' => 'cedar') do |app_data|
+      response = azuki.get_config_vars(app_data['name'])
+
+      assert_equal(200, response.status)
+      assert_equal({}, response.body)
+    end
+  end
+
+  def test_get_app_config_vars_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.get_config_vars(random_name)
+    end
+  end
+
+  def test_put_app_config_vars
+    with_app('stack' => 'cedar') do |app_data|
+      response = azuki.put_config_vars(app_data['name'], {'KEY' => 'value'})
+
+      assert_equal(200, response.status)
+      assert_equal({'KEY' => 'value'}, response.body)
+
+      azuki.delete_config_var(app_data['name'], 'KEY')
+    end
+  end
+
+  def test_put_app_config_vars_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.put_config_vars(random_name, {'KEY' => 'value'})
+    end
+  end
+
+end

data/test/test_domains.rb

@@ -0,0 +1,65 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+class TestDomains < MiniTest::Unit::TestCase
+
+  def test_delete_domain_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.delete_domain(random_name, 'example.com')
+    end
+  end
+
+  def test_delete_domain
+    with_app do |app_data|
+      domain = random_domain
+      azuki.post_domain(app_data['name'], domain)
+      response = azuki.delete_domain(app_data['name'], domain)
+
+      assert_equal(200, response.status)
+      assert_equal({}, response.body)
+    end
+  end
+
+  def test_delete_domains
+    with_app do |app_data|
+      azuki.post_domain(app_data['name'], random_domain)
+      response = azuki.delete_domains(app_data['name'])
+
+      assert_equal(200, response.status)
+      assert_equal("", response.body)
+    end
+  end
+
+  def test_get_domains
+    with_app do |app_data|
+      response = azuki.get_domains(app_data['name'])
+
+      assert_equal(200, response.status)
+      assert_equal([], response.body)
+    end
+  end
+
+  def test_get_domains_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.get_domains(random_name)
+    end
+  end
+
+  def test_post_domain
+    with_app do |app_data|
+      domain = random_domain
+      response = azuki.post_domain(app_data['name'], domain)
+
+      assert_equal(201, response.status)
+      assert_equal({'domain' => domain}, response.body)
+
+      azuki.delete_domain(app_data['name'], domain)
+    end
+  end
+
+  def test_post_domain_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.post_domain(random_name, 'example.com')
+    end
+  end
+
+end

data/test/test_error_conditions.rb

@@ -0,0 +1,11 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+class TestErrorConditions < MiniTest::Unit::TestCase
+
+  def test_request_without_app_returns_a_sensible_error
+    assert_raises(Azuki::API::Errors::NilApp) do
+      azuki.delete_domain("", 'example.com')
+    end
+  end
+
+end

data/test/test_features.rb

@@ -0,0 +1,87 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+class TestFeatures < MiniTest::Unit::TestCase
+
+  def setup
+    @feature_data ||= begin
+      data = File.read("#{File.dirname(__FILE__)}/../lib/azuki/api/mock/cache/get_features.json")
+      features_data = Azuki::API::OkJson.decode(data)
+      features_data.detect {|feature| feature['name'] == 'user_env_compile'}
+    end
+  end
+
+  def test_delete_feature
+    with_app do |app_data|
+      azuki.post_feature('user_env_compile', app_data['name'])
+      response = azuki.delete_feature('user_env_compile', app_data['name'])
+
+      assert_equal(200, response.status)
+      assert_equal(@feature_data, response.body)
+    end
+  end
+
+  def test_delete_feature_app_not_found
+    assert_raises(Azuki::API::Errors::RequestFailed) do
+      azuki.delete_feature('user_env_compile', random_name)
+    end
+  end
+
+  def test_delete_feature_feature_not_found
+    with_app do |app_data|
+      assert_raises(Azuki::API::Errors::NotFound) do
+        azuki.delete_feature(random_name, app_data['name'])
+      end
+    end
+  end
+
+  def test_get_features
+    with_app do |app_data|
+      response = azuki.get_features(app_data['name'])
+      data = File.read("#{File.dirname(__FILE__)}/../lib/azuki/api/mock/cache/get_features.json")
+
+      assert_equal(200, response.status)
+      assert_equal(Azuki::API::OkJson.decode(data), response.body)
+    end
+  end
+
+  def test_get_feature
+    with_app do |app_data|
+      response = azuki.get_feature('user_env_compile', app_data['name'])
+
+      assert_equal(200, response.status)
+      assert_equal(@feature_data, response.body)
+    end
+  end
+
+  def test_get_features_feature_not_found
+    with_app do |app_data|
+      assert_raises(Azuki::API::Errors::NotFound) do
+        azuki.get_feature(random_name, app_data['name'])
+      end
+    end
+  end
+
+  def test_post_feature
+    with_app do |app_data|
+      response = azuki.post_feature('user_env_compile', app_data['name'])
+
+      assert_equal(201, response.status)
+      assert_equal(@feature_data.merge('enabled' => true), response.body)
+    end
+  end
+
+  def test_post_feature_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.post_feature('user_env_compile', random_name)
+    end
+  end
+
+  def test_post_feature_feature_not_found
+    with_app do |app_data|
+      assert_raises(Azuki::API::Errors::NotFound) do
+        azuki.post_feature(random_name, app_data['name'])
+      end
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,48 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../lib/azuki/api")
+
+require 'rubygems'
+gem 'minitest' # ensure we are using the gem version
+require 'minitest/autorun'
+require 'time'
+
+DATA_PATH = File.expand_path("#{File.dirname(__FILE__)}/data")
+MOCK = ENV['MOCK'] != 'false'
+
+def data_site_crt
+  @data_site_crt ||= File.read(File.join(DATA_PATH, 'site.crt'))
+end
+
+def data_site_key
+  @data_site_key ||= File.read(File.join(DATA_PATH, 'site.key'))
+end
+
+def azuki
+  # ENV['AZUKI_API_KEY'] used for :api_key
+  Azuki::API.new(:mock => MOCK)
+end
+
+def random_domain
+  "#{random_name}.com"
+end
+
+def random_name
+  "azuki-rb-#{SecureRandom.hex(10)}"
+end
+
+def random_email_address
+  "email@#{random_name}.com"
+end
+
+def with_app(params={}, &block)
+  begin
+    data = azuki.post_app(params).body
+    @name = data['name']
+    ready = false
+    until ready
+      ready = azuki.request(:method => :put, :path => "/apps/#{@name}/status").status == 201
+    end
+    yield(data)
+  ensure
+    azuki.delete_app(@name) rescue nil
+  end
+end

data/test/test_keys.rb

@@ -0,0 +1,39 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+class TestKeys < MiniTest::Unit::TestCase
+  KEY_DATA = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCz29znMi/UJX/nvkRSO5FFugKhU9DkkI53E0vXUnP8zeLFxMgyUqmXryPVjWtGzz2LRWqjm14SbqHAmM44pGHVfBIp6wCKBWSUYGv/FxOulwYgtWzz4moxWLZrFyWWgJAnehcVUifHNgzKwT2ovWm2ns52681Z8yFK3K8/uLStDjLIaPePEOaxaTvgIxZNsfyEoXoHcyTPwdR1GtQuDTuDYqYmjmPCoKybYnXrTQ1QFuQxDneBkswQYSl0H2aLf3uBK4F01hr+azXQuSe39eSV4I/TqzmNJlanpILT9Jz3/J1i4r6brpF3AxLnFnb9ufIbzQAIa/VZIulfrZkcBsUl david@carbon.local"
+
+  def test_delete_key_key_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.delete_key(random_name)
+    end
+  end
+
+  def test_delete_key
+    azuki.post_key(KEY_DATA)
+    response = azuki.delete_key('david@carbon.local')
+
+    assert_equal(200, response.status)
+  end
+
+  def test_delete_keys
+    response = azuki.delete_keys
+
+    assert_equal(200, response.status)
+  end
+
+  def test_get_keys
+    response = azuki.get_keys
+
+    assert_equal(200, response.status)
+  end
+
+  def test_post_key
+    response = azuki.post_key(KEY_DATA)
+
+    assert_equal(200, response.status)
+
+    azuki.delete_key('david@carbon.local')
+  end
+
+end

data/test/test_login.rb

@@ -0,0 +1,20 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+class TestLogin < MiniTest::Unit::TestCase
+
+  def test_post_login
+    # FIXME: user/pass will only work in mock for now, maybe use ENV
+    response = azuki.post_login('email@example.com', 'fake_password')
+
+    assert_equal(200, response.status)
+  end
+
+  def test_post_login_implied
+    # FIXME: user/pass will only work in mock for now, maybe use ENV
+    _azuki_ = Azuki::API.new(:mock => true, :username => 'email@example.com', :password => 'fake_password')
+    response = _azuki_.get_apps
+
+    assert_equal(200, response.status)
+  end
+
+end

data/test/test_logs.rb

@@ -0,0 +1,29 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+class TestLogs < MiniTest::Unit::TestCase
+
+  def test_get_logs
+    with_app do |app_data|
+      response = azuki.get_logs(app_data['name'], 'logplex' => true)
+
+      assert_equal(200, response.status)
+      assert_match(%r{^https://logplex\.azukiapp\.com/sessions/[-a-zA-Z0-9]*\?srv=[0-9]*$}, response.body)
+    end
+  end
+
+  def test_get_logs_no_options
+    with_app do |app_data|
+      response = azuki.get_logs(app_data['name'])
+
+      assert_equal(200, response.status)
+      assert_match(%r{^https://logplex\.azukiapp\.com/sessions/[-a-zA-Z0-9]*\?srv=[0-9]*$}, response.body)
+    end
+  end
+  
+  def test_get_logs_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.get_logs(random_name, 'logplex' => true)
+    end
+  end
+
+end

data/test/test_processes.rb

@@ -0,0 +1,245 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+class TestProcesses < MiniTest::Unit::TestCase
+
+  def test_get_ps
+    with_app do |app_data|
+      response = azuki.get_ps(app_data['name'])
+      ps = response.body.first
+
+      assert_equal(200, response.status)
+      assert_equal('up', ps['action'])
+      assert_equal(app_data['name'], ps['app_name'])
+      assert_equal(false, ps['attached'])
+      assert_equal('thin -p $PORT -e $RACK_ENV -R $AZUKI_RACK start', ps['command'])
+      # elapsed
+      # pretty_state
+      assert_equal('web.1', ps['process'])
+      assert_equal(nil, ps['rendevous_url'])
+      assert_equal('NONE', ps['slug'])
+      assert_equal('created', ps['state'])
+      # transitioned_at
+      assert_equal('Dyno', ps['type'])
+      # upid
+    end
+  end
+
+  def test_get_ps_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.get_ps(random_name)
+    end
+  end
+
+  def test_post_ps
+    with_app do |app_data|
+      command = 'pwd'
+      response = azuki.post_ps(app_data['name'], command)
+      ps = response.body
+
+      assert_equal(200, response.status)
+      assert_equal('complete', ps['action'])
+      refute(ps['attached'])
+      assert_equal(command, ps['command'])
+      # elapsed
+      # pretty_state
+      assert_equal('run.1', ps['process'])
+      assert_nil(ps['rendevous_url'])
+      assert_equal('NONE', ps['slug'])
+      # depending on timing it will be one of these two states
+      assert_includes(['created', 'starting'], ps['state'])
+      # transitioned_at
+      assert_equal('Ps', ps['type'])
+      # upid
+    end
+  end
+
+  def test_post_ps_with_attach
+    with_app do |app_data|
+      command = 'pwd'
+      response = azuki.post_ps(app_data['name'], command, 'attach' => true)
+      ps = response.body
+
+      assert_equal(200, response.status)
+      assert_equal('complete', ps['action'])
+      assert(ps['attached'])
+      assert_equal(command, ps['command'])
+      # elapsed
+      # pretty_state
+      assert_equal('run.1', ps['process'])
+      refute_nil(ps['rendezvous_url'])
+      assert_equal('NONE', ps['slug'])
+      # depending on timing it will be one of these two states
+      assert_includes(['created', 'starting'], ps['state'])
+      # transitioned_at
+      assert_equal(nil, ps['type'])
+      # upid
+    end
+  end
+
+  def test_post_ps_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.post_ps(random_name, 'pwd')
+    end
+  end
+
+  def test_post_ps_restart
+    with_app do |app_data|
+      response = azuki.post_ps_restart(app_data['name'])
+
+      assert_equal(200, response.status)
+      assert_equal('ok', response.body)
+    end
+  end
+
+  def test_post_ps_restart_with_ps
+    with_app do |app_data|
+      response = azuki.post_ps_restart(app_data['name'], 'ps' => 'web.1')
+
+      assert_equal(200, response.status)
+      assert_equal('ok', response.body)
+    end
+  end
+
+  def test_post_ps_restart_with_type
+    with_app do |app_data|
+      response = azuki.post_ps_restart(app_data['name'], 'type' => 'web')
+
+      assert_equal(200, response.status)
+      assert_equal('ok', response.body)
+    end
+  end
+
+  def test_post_ps_restart_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.post_ps_restart(random_name)
+    end
+  end
+
+  def test_post_ps_scale_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.post_ps_scale(random_name, 'web', 2)
+    end
+  end
+
+  def test_post_ps_scale_down
+    with_app('stack' => 'cedar') do |app_data|
+      azuki.post_ps_scale(app_data['name'], 'web', 2)
+      response = azuki.post_ps_scale(app_data['name'], 'web', 1)
+
+      assert_equal(200, response.status)
+      assert_equal("1", response.body)
+    end
+  end
+
+  def test_post_ps_scale_type_not_found
+    assert_raises(Azuki::API::Errors::RequestFailed) do
+      with_app('stack' => 'cedar') do |app_data|
+        azuki.post_ps_scale(app_data['name'], 'run', 2)
+      end
+    end
+  end
+
+  def test_post_ps_scale_up
+    with_app('stack' => 'cedar') do |app_data|
+      response = azuki.post_ps_scale(app_data['name'], 'web', 2)
+
+      assert_equal(200, response.status)
+      assert_equal("2", response.body)
+    end
+  end
+
+  def test_post_ps_scale_without_cedar
+    assert_raises(Azuki::API::Errors::RequestFailed) do
+      with_app do |app_data|
+        azuki.post_ps_scale(app_data['name'], 'web', 2)
+      end
+    end
+  end
+
+  def test_post_ps_stop
+    assert_raises(Azuki::API::Errors::RequestFailed) do
+      with_app do |app_data|
+        azuki.post_ps_stop(app_data['name'], {})
+      end
+    end
+  end
+
+  def test_post_ps_stop_with_ps
+    with_app do |app_data|
+      response = azuki.post_ps_stop(app_data['name'], 'ps' => 'web.1')
+
+      assert_equal(200, response.status)
+      assert_equal('ok', response.body)
+    end
+  end
+
+  def test_post_ps_stop_with_type
+    with_app do |app_data|
+      response = azuki.post_ps_stop(app_data['name'], 'type' => 'web')
+
+      assert_equal(200, response.status)
+      assert_equal('ok', response.body)
+    end
+  end
+
+  def test_post_ps_stop_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.post_ps_stop(random_name, {})
+    end
+  end
+
+  def test_put_dynos
+    with_app do |app_data|
+      dynos = 1
+      response = azuki.put_dynos(app_data['name'], dynos)
+
+      assert_equal(200, response.status)
+      assert_equal({
+        'name' => app_data['name'],
+        'dynos' => dynos
+      }, response.body)
+    end
+  end
+
+  def test_put_dynos_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.put_dynos(random_name, 1)
+    end
+  end
+
+  def test_put_dynos_with_cedar
+    assert_raises(Azuki::API::Errors::RequestFailed) do
+      with_app('stack' => 'cedar') do |app_data|
+        azuki.put_dynos(app_data['name'], 2)
+      end
+    end
+  end
+
+  def test_put_workers
+    with_app do |app_data|
+      workers = 1
+      response = azuki.put_workers(app_data['name'], workers)
+
+      assert_equal(200, response.status)
+      assert_equal({
+        'name' => app_data['name'],
+        'workers' => workers
+      }, response.body)
+    end
+  end
+
+  def test_put_workers_app_not_found
+    assert_raises(Azuki::API::Errors::NotFound) do
+      azuki.put_workers(random_name, 1)
+    end
+  end
+
+  def test_put_workers_with_cedar
+    assert_raises(Azuki::API::Errors::RequestFailed) do
+      with_app('stack' => 'cedar') do |app_data|
+        azuki.put_workers(app_data['name'], 2)
+      end
+    end
+  end
+
+end