azuki-api 0.0.2

data/lib/azuki/api/addons.rb

@@ -0,0 +1,48 @@
+module Azuki
+  class API
+
+    # DELETE /apps/:app/addons/:addon
+    def delete_addon(app, addon)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/apps/#{app}/addons/#{addon}"
+      )
+    end
+
+    # GET /addons
+    # GET /apps/:app/addons
+    def get_addons(app=nil)
+      path = if app
+        "/apps/#{app}/addons"
+      else
+        "/addons"
+      end
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => path
+      )
+    end
+
+    # POST /apps/:app/addons/:addon
+    def post_addon(app, addon, config = {})
+      request(
+        :expects  => 200,
+        :method   => :post,
+        :path     => "/apps/#{app}/addons/#{addon}",
+        :query    => addon_params(config)
+      )
+    end
+
+    # PUT /apps/:app/addons/:addon
+    def put_addon(app, addon, config = {})
+      request(
+        :expects  => 200,
+        :method   => :put,
+        :path     => "/apps/#{app}/addons/#{addon}",
+        :query    => addon_params(config)
+      )
+    end
+  end
+end

data/lib/azuki/api/apps.rb

@@ -0,0 +1,71 @@
+module Azuki
+  class API
+
+    # DELETE /apps/:app
+    def delete_app(app)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/apps/#{app}"
+      )
+    end
+
+    # GET /apps
+    def get_apps
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/apps"
+      )
+    end
+
+    # GET /apps/:app
+    def get_app(app)
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/apps/#{app}"
+      )
+    end
+
+    # GET /apps/:app/server/maintenance
+    def get_app_maintenance(app)
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/apps/#{app}/server/maintenance"
+      )
+    end
+
+    # POST /apps
+    def post_app(params={})
+      request(
+        :expects  => 202,
+        :method   => :post,
+        :path     => '/apps',
+        :query    => app_params(params)
+      )
+    end
+
+    # POST /apps/:app/server/maintenance
+    def post_app_maintenance(app, maintenance_mode)
+      request(
+        :expects  => 200,
+        :method   => :post,
+        :path     => "/apps/#{app}/server/maintenance",
+        :query    => {'maintenance_mode' => maintenance_mode}
+      )
+    end
+
+    # PUT /apps/:app
+    def put_app(app, params)
+      request(
+        :expects  => 200,
+        :method   => :put,
+        :path     => "/apps/#{app}",
+        :query    => app_params(params)
+      )
+    end
+
+  end
+end

data/lib/azuki/api/attachments.rb

@@ -0,0 +1,14 @@
+module Azuki
+  class API
+
+    # GET /apps/:app/attachments
+    def get_attachments(app)
+      request(
+        :expects => 200,
+        :method => :get,
+        :path => "/apps/#{app}/attachments"
+      )
+    end
+
+  end
+end

data/lib/azuki/api/collaborators.rb

@@ -0,0 +1,33 @@
+module Azuki
+  class API
+
+    # DELETE /apps/:app/collaborators/:email
+    def delete_collaborator(app, email)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/apps/#{app}/collaborators/#{email}"
+      )
+    end
+
+    # GET /apps/:app/collaborators
+    def get_collaborators(app)
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/apps/#{app}/collaborators"
+      )
+    end
+
+    # POST /apps/:app/collaborators
+    def post_collaborator(app, email)
+      request(
+        :expects  => [200, 201],
+        :method   => :post,
+        :path     => "/apps/#{app}/collaborators",
+        :query    => {'collaborator[email]' => email}
+      )
+    end
+
+  end
+end

data/lib/azuki/api/config_vars.rb

@@ -0,0 +1,33 @@
+module Azuki
+  class API
+
+    # DELETE /apps/:app/config_vars/:key
+    def delete_config_var(app, key)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/apps/#{app}/config_vars/#{escape(key)}"
+      )
+    end
+
+    # GET /apps/:app/config_vars
+    def get_config_vars(app)
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/apps/#{app}/config_vars"
+      )
+    end
+
+    # PUT /apps/:app/config_vars
+    def put_config_vars(app, vars)
+      request(
+        :body     => Azuki::API::OkJson.encode(vars),
+        :expects  => 200,
+        :method   => :put,
+        :path     => "/apps/#{app}/config_vars"
+      )
+    end
+
+  end
+end

data/lib/azuki/api/domains.rb

@@ -0,0 +1,42 @@
+module Azuki
+  class API
+
+    # DELETE /apps/:app/domains/:domain
+    def delete_domain(app, domain)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/apps/#{app}/domains/#{escape(domain)}"
+      )
+    end
+
+    # DELETE /apps/:app/domains
+    def delete_domains(app)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/apps/#{app}/domains"
+      )
+    end
+
+    # GET /apps/:app/domains
+    def get_domains(app)
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/apps/#{app}/domains"
+      )
+    end
+
+    # POST /apps/:app/domains
+    def post_domain(app, domain)
+      request(
+        :expects  => 201,
+        :method   => :post,
+        :path     => "/apps/#{app}/domains",
+        :query    => {'domain_name[domain]' => domain}
+      )
+    end
+
+  end
+end

data/lib/azuki/api/errors.rb

@@ -0,0 +1,26 @@
+module Azuki
+  class API
+    module Errors
+      class Error < StandardError; end
+
+      class ErrorWithResponse < Error
+        attr_reader :response
+
+        def initialize(message, response)
+          super message
+          @response = response
+        end
+      end
+
+      class Unauthorized < ErrorWithResponse; end
+      class VerificationRequired < ErrorWithResponse; end
+      class Forbidden < ErrorWithResponse; end
+      class NotFound < ErrorWithResponse; end
+      class Timeout < ErrorWithResponse; end
+      class Locked < ErrorWithResponse; end
+      class RequestFailed < ErrorWithResponse; end
+      class NilApp < ErrorWithResponse; end
+
+    end
+  end
+end

data/lib/azuki/api/features.rb

@@ -0,0 +1,45 @@
+module Azuki
+  class API
+
+    # DELETE /features/:feature
+    def delete_feature(feature, app = nil)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/features/#{feature}",
+        :query    => { 'app' => app }
+      )
+    end
+
+    # GET /features
+    def get_features(app = nil)
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/features",
+        :query    => { 'app' => app }
+      )
+    end
+
+    # GET /features/:feature
+    def get_feature(feature, app = nil)
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/features/#{feature}",
+        :query    => { 'app' => app }
+      )
+    end
+
+    # POST /features/:feature
+    def post_feature(feature, app = nil)
+      request(
+        :expects  => [200, 201],
+        :method   => :post,
+        :path     => "/features/#{feature}",
+        :query    => { 'app' => app }
+      )
+    end
+
+  end
+end

data/lib/azuki/api/keys.rb

@@ -0,0 +1,42 @@
+module Azuki
+  class API
+
+    # DELETE /user/keys/:key
+    def delete_key(key)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/user/keys/#{escape(key)}"
+      )
+    end
+
+    # DELETE /user/keys
+    def delete_keys
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/user/keys"
+      )
+    end
+
+    # GET /user/keys
+    def get_keys
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/user/keys"
+      )
+    end
+
+    # POST /user/keys
+    def post_key(key)
+      request(
+        :body     => key,
+        :expects  => 200,
+        :method   => :post,
+        :path     => "/user/keys"
+      )
+    end
+
+  end
+end

data/lib/azuki/api/login.rb

@@ -0,0 +1,14 @@
+module Azuki
+  class API
+
+    def post_login(username, password)
+      request(
+        :expects  => 200,
+        :method   => :post,
+        :path     => '/login',
+        :query    => { 'username' => username, 'password' => password }
+      )
+    end
+
+  end
+end

data/lib/azuki/api/logs.rb

@@ -0,0 +1,18 @@
+module Azuki
+  class API
+
+    # GET /apps/:app/logs
+    def get_logs(app, options = {})
+      options = {
+        'logplex' => 'true'
+      }.merge(options)
+      request(
+        :expects  => 200,
+        :method   => :get,
+        :path     => "/apps/#{app}/logs",
+        :query    => options
+      )
+    end
+
+  end
+end

data/lib/azuki/api/mock.rb

@@ -0,0 +1,179 @@
+require 'azuki/api/mock/addons'
+require 'azuki/api/mock/apps'
+require 'azuki/api/mock/attachments'
+require 'azuki/api/mock/collaborators'
+require 'azuki/api/mock/config_vars'
+require 'azuki/api/mock/domains'
+require 'azuki/api/mock/features'
+require 'azuki/api/mock/keys'
+require 'azuki/api/mock/login'
+require 'azuki/api/mock/logs'
+require 'azuki/api/mock/processes'
+require 'azuki/api/mock/releases'
+require 'azuki/api/mock/stacks'
+require 'azuki/api/mock/user'
+
+module Azuki
+  class API
+    module Mock
+
+      APP_NOT_FOUND  = { :body => 'App not found.',   :status => 404 }
+      USER_NOT_FOUND = { :body => 'User not found.',  :status => 404 }
+
+      @mock_data = Hash.new do |hash, key|
+        hash[key] = {
+          :addons           => {},
+          :apps             => [],
+          :attachments      => {},
+          :collaborators    => {},
+          :config_vars      => {},
+          :domains          => {},
+          :features         => {
+            :app  => Hash.new {|hash,key| hash[key] = []},
+            :user => []
+          },
+          :keys             => [],
+          :maintenance_mode => [],
+          :ps               => {},
+          :releases         => {},
+          :user             => {}
+        }
+      end
+
+      def self.add_mock_app_addon(mock_data, app, addon)
+        addon_data = get_mock_addon(mock_data, addon)
+        mock_data[:addons][app] << addon_data.reject {|key, value| !['attachable', 'beta', 'configured', 'consumes_dyno_hours', 'description', 'group_description', 'name', 'plan_description', 'price', 'slug', 'state', 'terms_of_service', 'url'].include?(key)}
+        add_mock_release(mock_data, app, {'descr' => "Add-on add #{addon_data['name']}"})
+      end
+
+      def self.add_mock_release(mock_data, app, release_data)
+        env = if get_mock_app(mock_data, app)['stack'] == 'cedar'
+          {
+            'BUNDLE_WITHOUT'      => 'development:test',
+            'DATABASE_URL'        => 'postgres://username:password@ec2-123-123-123-123.compute-1.amazonaws.com/username',
+            'LANG'                => 'en_US.UTF-8',
+            'RACK_ENV'            => 'production'
+          }
+        else
+          {}
+        end
+        version = mock_data[:releases][app].map {|release| release['name'][1..-1].to_i}.max || 0
+        mock_data[:releases][app] << {
+          'addons'      => mock_data[:addons][app].map {|addon| addon['name']},
+          'commit'      => nil,
+          'created_at'  => timestamp,
+          'descr'       => "",
+          'env'         => env,
+          'name'        => "v#{version + 1}",
+          'pstable'     => { 'web' => '' },
+          'user'        => 'email@example.com'
+        }.merge(release_data)
+      end
+
+      def self.get_mock_addon(mock_data, addon)
+        @addons ||= begin
+          data = File.read("#{File.dirname(__FILE__)}/mock/cache/get_addons.json")
+          Azuki::API::OkJson.decode(data)
+        end
+        @addons.detect {|addon_data| addon_data['name'] == addon}
+      end
+
+      def self.get_mock_addon_price(mock_data, addon)
+        addon_data = get_mock_addon(mock_data, addon)
+        price_cents = addon_data['price_cents'] || 0
+        price = format("$%d/mo", price_cents / 100)
+        if price == '$0/mo'
+          price = 'free'
+        end
+        price
+      end
+
+      def self.get_mock_app(mock_data, app)
+        mock_data[:apps].detect {|app_data| app_data['name'] == app}
+      end
+
+      def self.get_mock_app_addon(mock_data, app, addon)
+        mock_data[:addons][app].detect {|addon_data| addon_data['name'] == addon}
+      end
+
+      def self.get_mock_app_domain(mock_data, app, domain)
+        mock_data[:domains][app].detect {|domain_data| domain_data['domain'] == domain}
+      end
+
+      def self.get_mock_collaborator(mock_data, app, email)
+        mock_data[:collaborators][app].detect {|collaborator_data| collaborator_data['email'] == email}
+      end
+
+      def self.get_mock_feature(mock_data, feature)
+        @features ||= begin
+          data = File.read("#{File.dirname(__FILE__)}/mock/cache/get_features.json")
+          Azuki::API::OkJson.decode(data)
+        end
+        @features.detect {|feature_data| feature_data['name'] == feature}
+      end
+
+      def self.get_mock_key(mock_data, key)
+        mock_data[:keys].detect {|key_data| %r{ #{Regexp.escape(key)}$}.match(key_data['contents'])}
+      end
+
+      def self.get_mock_processes(mock_data, app)
+        mock_data[:ps][app].map do |ps|
+
+          elapsed = Time.now.to_i - Time.parse(ps['transitioned_at']).to_i
+          ps['elapsed'] = elapsed
+
+          pretty_elapsed = if elapsed < 60
+            "#{elapsed}s"
+          elsif elapsed < (60 * 60)
+            "#{elapsed / 60}m"
+          else
+            "#{elapsed / 60 / 60}h"
+          end
+          ps['pretty_state'] = "#{ps['state']} for #{pretty_elapsed}"
+
+          ps
+        end
+      end
+
+      def self.parse_stub_params(params)
+        mock_data = nil
+
+        if params[:headers].has_key?('Authorization')
+          api_key = Base64.decode64(params[:headers]['Authorization']).split(':').last
+
+          parsed = params.dup
+          begin # try to JSON decode
+            parsed[:body] &&= Azuki::API::OkJson.decode(parsed[:body])
+          rescue # else leave as is
+          end
+          mock_data = @mock_data[api_key]
+        end
+
+        [parsed, mock_data]
+      end
+
+      def self.remove_mock_app_addon(mock_data, app, addon)
+        addon_data = mock_data[:addons][app].detect {|addon_data| addon_data['name'] == addon}
+        mock_data[:addons][app].delete(addon_data)
+        add_mock_release(mock_data, app, {'descr' => "Add-on remove #{addon_data['name']}"})
+      end
+
+      def self.unescape(string)
+        CGI.unescape(string)
+      end
+
+      def self.with_mock_app(mock_data, app, &block)
+        if app_data = get_mock_app(mock_data, app)
+          yield(app_data)
+        else
+          APP_NOT_FOUND
+        end
+      end
+
+      def self.timestamp
+        Time.now.strftime("%G/%m/%d %H:%M:%S %z")
+      end
+
+    end
+  end
+end