heroku-api 0.1.0

data/lib/heroku/api/domains.rb

@@ -0,0 +1,33 @@
+module Heroku
+  class API
+
+    # DELETE /apps/:app/domains/:domain
+    def delete_domain(app, domain)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/apps/#{app}/domains/#{CGI.escape(domain)}"
+      )
+    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/heroku/api/errors.rb

@@ -0,0 +1,9 @@
+module Heroku
+  class API
+    module Errors
+      class Error < StandardError; end
+
+      class NotFound < Error; end
+    end
+  end
+end

data/lib/heroku/api/keys.rb

@@ -0,0 +1,42 @@
+module Heroku
+  class API
+
+    # DELETE /user/keys/:key
+    def delete_key(key)
+      request(
+        :expects  => 200,
+        :method   => :delete,
+        :path     => "/user/keys/#{CGI.escape(key).gsub('.','%2E')}"
+      )
+    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/heroku/api/logs.rb

@@ -0,0 +1,18 @@
+module Heroku
+  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/heroku/api/mock.rb

@@ -0,0 +1,176 @@
+require 'heroku/api/mock/addons'
+require 'heroku/api/mock/apps'
+require 'heroku/api/mock/collaborators'
+require 'heroku/api/mock/config_vars'
+require 'heroku/api/mock/domains'
+require 'heroku/api/mock/keys'
+require 'heroku/api/mock/logs'
+require 'heroku/api/mock/processes'
+require 'heroku/api/mock/releases'
+require 'heroku/api/mock/stacks'
+
+module Heroku
+  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             => [],
+          :collaborators    => {},
+          :config_vars      => {},
+          :domains          => {},
+          :keys             => [],
+          :maintenance_mode => [],
+          :ps               => {},
+          :releases         => {}
+        }
+      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| !['beta', 'configured', 'description', 'name', 'state', 'url'].include?(key)}
+        version = mock_data[:releases][app].map {|release| release['name'][1..-1].to_i}.max || 0
+        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',
+            'SHARED_DATABASE_URL' => 'postgres://username:password@ec2-123-123-123-123.compute-1.amazonaws.com/username'
+          }
+        else
+          {}
+        end
+        mock_data[:releases][app] << {
+          'addons'      => mock_data[:addons][app].map {|addon| addon['name']},
+          'commit'      => nil,
+          'created_at'  => timestamp,
+          'descr'       => "Add-on add #{addon_data['name']}",
+          'env'         => env,
+          'name'        => "v#{version + 1}",
+          'pstable'     => { 'web' => '' },
+          'user'        => 'email@example.com'
+        }
+      end
+
+      def self.get_mock_addon(mock_data, addon)
+        @addons ||= begin
+          data = File.read("#{File.dirname(__FILE__)}/mock/cache/get_addons.json")
+          Heroku::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_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|
+
+          # swap day/month positions for Time.parse
+          time_parts = ps['transitioned_at'].split(' ')
+          date_parts = time_parts.first.split('/')
+          date_parts[1], date_parts[2] = date_parts[2], date_parts[1]
+          time_parts[0] = date_parts.join('/')
+          munged_time = time_parts.join(' ')
+          elapsed = Time.now.to_i - Time.parse(munged_time).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)
+        api_key = Base64.decode64(params[:headers]['Authorization']).split(':').last
+
+        parsed = params.dup
+        begin # try to JSON decode
+          parsed[:body] &&= Heroku::API::OkJson.decode(parsed[:body])
+        rescue # else leave as is
+        end
+
+        [parsed, @mock_data[api_key]]
+      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)
+        version = mock_data[:releases][app].map {|release| release['name'][1..-1].to_i}.max || 0
+        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',
+            'SHARED_DATABASE_URL' => 'postgres://username:password@ec2-123-123-123-123.compute-1.amazonaws.com/username'
+          }
+        else
+          {}
+        end
+        mock_data[:releases][app] << {
+          'addons'      => mock_data[:addons][app].map {|addon| addon['name']},
+          'commit'      => nil,
+          'created_at'  => timestamp,
+          'descr'       => "Add-on remove #{addon_data['name']}",
+          'env'         => env,
+          'name'        => "v#{version + 1}",
+          'pstable'     => { 'web' => '' },
+          'user'        => 'email@example.com'
+        }
+      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/%d/%m %H:%M:%S %z")
+      end
+
+    end
+  end
+end

data/lib/heroku/api/mock/addons.rb

@@ -0,0 +1,153 @@
+module Heroku
+  class API
+    module Mock
+
+      # stub DELETE /apps/:app/addons/:addon
+      Excon.stub(:expects => 200, :method => :delete, :path => %r{^/apps/([^/]+)/addons/([^/]+)$}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, addon, _ = request_params[:captures][:path]
+        with_mock_app(mock_data, app) do
+          addon_names = mock_data[:addons][app].map {|data| data['name']}
+          if addon_data = get_mock_addon(mock_data, addon)
+            # addon exists
+            if app_addon_data = get_mock_app_addon(mock_data, app, addon)
+              # addon is currently installed
+              remove_mock_app_addon(mock_data, app, addon)
+              {
+                :body   => Heroku::API::OkJson.encode({
+                  :message  => nil,
+                  :price    => get_mock_addon_price(mock_data, addon),
+                  :status   => 'Uninstalled'
+                }),
+                :status => 200
+              }
+            else
+              # addon is not currently installed
+              {
+                :body   => Heroku::API::OkJson.encode({'error' => "The add-on #{addon} is not installed for this app. Did you mean:\n\t#{addon_names.join("\n\t")}"}),
+                :status => 422
+              }
+            end
+          else
+            # addon does not exist
+            {
+              :body   => Heroku::API::OkJson.encode({'error' => "Could not find add-on #{addon}. Did you mean:\n\t#{addon_names.join("\n\t")}"}),
+              :status => 422
+            }
+          end
+        end
+      end
+
+      # stub GET /addons
+      Excon.stub(:expects => 200, :method => :get, :path => "/addons") do |params|
+        request_params, mock_data = parse_stub_params(params)
+        {
+          :body   => File.read("#{File.dirname(__FILE__)}/cache/get_addons.json"),
+          :status => 200
+        }
+      end
+
+      # stub GET /apps/:app/addons
+      Excon.stub(:expects => 200, :method => :get, :path => %r{^/apps/([^/]+)/addons$}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, _ = request_params[:captures][:path]
+        with_mock_app(mock_data, app) do
+          {
+            :body   => Heroku::API::OkJson.encode(mock_data[:addons][app].map {|addon| addon['configured'] = true; addon}),
+            :status => 200
+          }
+        end
+      end
+
+      # stub POST /apps/:app/addons
+      Excon.stub(:expects => 200, :method => :post, :path => %r{^/apps/([^/]+)/addons/([^/]+)$}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, addon, _ = request_params[:captures][:path]
+        with_mock_app(mock_data, app) do
+          if addon_data = get_mock_addon(mock_data, addon)
+            # addon exists
+            unless app_addon_type_data = mock_data[:addons][app].detect {|data| data['name'] =~ %r{^#{addon.split(':').first}}}
+              # addon of same type does not exist
+              unless app_addon_data = get_mock_app_addon(mock_data, app, addon)
+                # addon is not currently installed
+                add_mock_app_addon(mock_data, app, addon)
+                {
+                  :body   => Heroku::API::OkJson.encode({
+                    :message  => nil,
+                    :price    => get_mock_addon_price(mock_data, addon),
+                    :status   => 'Installed'
+                  }),
+                  :status => 200
+                }
+              else
+                # addon is currently installed
+                {
+                  :body   => Heroku::API::OkJson.encode({'error' => "Add-on already installed."}),
+                  :status => 422
+                }
+              end
+            else
+              # addon of same type exists
+              {
+                :body   => Heroku::API::OkJson.encode({'error' => "#{app_addon_type_data['name']} add-on already added.\nTo upgrade, use addons:upgrade instead.\n"}),
+                :status => 422
+              }
+            end
+          else
+            # addon does not exist
+            {
+              :body   => Heroku::API::OkJson.encode({'error' => "Add-on not found."}),
+              :status => 422
+            }
+          end
+        end
+      end
+
+      # stub PUT /apps/:app/addons
+      Excon.stub(:expects => 200, :method => :put, :path => %r{^/apps/([^/]+)/addons/([^/]+)$}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, addon, _ = request_params[:captures][:path]
+        with_mock_app(mock_data, app) do
+          if addon_data = get_mock_addon(mock_data, addon)
+            # addon exists
+            if mock_data[:addons][app].detect {|data| data['name'] =~ %r{^#{addon.split(':').first}}}
+              # addon of same type exists
+              unless app_addon_data = get_mock_app_addon(mock_data, app, addon)
+                # addon is not currently installed
+                mock_data[:addons][app].delete(app_addon_data)
+                add_mock_app_addon(mock_data, app, addon)
+                {
+                  :body   => Heroku::API::OkJson.encode({
+                    :message  => nil,
+                    :price    => get_mock_addon_price(mock_data, addon),
+                    :status   => 'Updated'
+                  }),
+                  :status => 200
+                }
+              else
+                # addon is currently installed
+                {
+                  :body   => Heroku::API::OkJson.encode({'error' => "Add-on already installed."}),
+                  :status => 422
+                }
+              end
+            else
+              # addon of same type not installed
+              {
+                :body   => Heroku::API::OkJson.encode({'error' => "Can't upgrade, no #{addon.split(':').join(' ')} add-on has been added.\nTo add, use addons:add instead.\n"}),
+                :status => 422
+              }
+            end
+          else
+            # addon does not exist
+            {
+              :body   => Heroku::API::OkJson.encode({'error' => "Add-on not found."}),
+              :status => 422
+            }
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/heroku/api/mock/apps.rb

@@ -0,0 +1,184 @@
+module Heroku
+  class API
+    module Mock
+
+      # stub DELETE /apps/:app
+      Excon.stub(:expects => 200, :method => :delete, :path => %r{^/apps/([^/]+)$} ) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, _ = request_params[:captures][:path]
+        with_mock_app(mock_data, app) do |app_data|
+          mock_data[:addons].delete(app)
+          mock_data[:apps].delete(app_data)
+          mock_data[:collaborators].delete(app)
+          mock_data[:config_vars].delete(app)
+          mock_data[:domains].delete(app)
+          mock_data[:ps].delete(app)
+          mock_data[:releases].delete(app)
+          {
+            :body   => Heroku::API::OkJson.encode({}),
+            :status => 200
+          }
+        end
+      end
+
+      # stub GET /apps/
+      Excon.stub(:expects => 200, :method => :get, :path => '/apps') do |params|
+        request_params, mock_data = parse_stub_params(params)
+        {
+          :body   => Heroku::API::OkJson.encode(mock_data[:apps]),
+          :status => 200
+        }
+      end
+
+      # stub GET /apps/:app
+      Excon.stub(:expects => 200, :method => :get, :path => %r{^/apps/([^/]+)$} ) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, _ = request_params[:captures][:path]
+        with_mock_app(mock_data, app) do |app_data|
+          {
+            :body   => Heroku::API::OkJson.encode(app_data),
+            :status => 200
+          }
+        end
+      end
+
+      # stub POST /apps
+      Excon.stub(:expects => 202, :method => :post, :path => '/apps') do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app = request_params[:query].has_key?('app[name]') && request_params[:query]['app[name]'] || "generated-name-#{rand(999)}"
+
+        if get_mock_app(mock_data, app)
+          {
+            :body => Heroku::API::OkJson.encode('error' => 'Name is already taken'),
+            :status => 422
+          }
+        else
+          stack = request_params[:query].has_key?('app[stack]') && request_params[:query]['app[stack]'] || 'bamboo-mri-1.9.2'
+          app_data = {
+            'created_at'          => timestamp,
+            'create_status'       => 'complete',
+            'id'                  => rand(99999),
+            'name'                => app,
+            'owner_email'         => 'email@example.com',
+            'slug_size'           => nil,
+            'stack'               => request_params[:query].has_key?('app[stack]') && request_params[:query]['app[stack]'] || 'bamboo-mri-1.9.2',
+            'requested_stack'     => nil,
+            'git_url'             => "git@heroku.com:#{app}.git",
+            'repo_migrate_status' => 'complete',
+            'repo_size'           => nil,
+            'dynos'               => 0,
+            'web_url'             => "http://#{app}.herokuapp.com/",
+            'workers'             => 0
+          }
+
+          mock_data[:addons][app] = []
+          mock_data[:apps] << app_data
+          mock_data[:collaborators][app] = [{
+            'access' => 'edit',
+            'email'  => 'email@example.com'
+          }]
+          mock_data[:config_vars][app] = {}
+          mock_data[:domains][app] = []
+          mock_data[:ps][app] = [{
+            'action'          => 'up',
+            'app_name'        => app,
+            'attached'        => false,
+            'command'         => nil, # set by stack below
+            'elapsed'         => 0,
+            'pretty_state'    => 'created for 0s',
+            'process'         => 'web.1',
+            'rendezvous_url'  => nil,
+            'slug'            => 'NONE',
+            'state'           => 'created',
+            'transitioned_at' => app_data['created_at'],
+            'type'            => nil, # set by stack below
+            'upid'            => rand(99999999).to_s
+          }]
+          mock_data[:releases][app] = []
+
+          add_mock_app_addon(mock_data, app, 'logging:basic')
+          if stack == 'cedar'
+            add_mock_app_addon(mock_data, app, 'releases:basic')
+            mock_data[:ps][app].first['type'] = 'Ps'
+          else
+            add_mock_app_addon(mock_data, app, 'shared-database:5mb')
+            mock_data[:config_vars][app] = {
+              'BUNDLE_WITHOUT' => 'development:test',
+              'LANG' => 'en_US.UTF-8',
+              'RACK_ENV' => 'production'
+            }
+            mock_data[:ps][app].first['command']  = 'thin -p $PORT -e $RACK_ENV -R $HEROKU_RACK start'
+            mock_data[:ps][app].first['type']     = 'Dyno'
+          end
+
+          {
+            :body   => Heroku::API::OkJson.encode(app_data),
+            :status => 202
+          }
+        end
+      end
+
+      # stub POST /apps/:app/server/maintenance
+      Excon.stub(:expects => 200, :method => :post, :path => %r{^/apps/([^/]+)/server/maintenance$}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, _ = request_params[:captures][:path].first
+
+        with_mock_app(mock_data, app) do
+          case request_params[:query]['maintenance_mode']
+          when '0'
+            mock_data[:maintenance_mode] -= [app]
+          when '1'
+            mock_data[:maintenance_mode] |= [app]
+          end
+
+          {
+            :status => 200
+          }
+        end
+      end
+
+      # stub PUT /apps/:app
+      Excon.stub(:expects => 200, :method => :put, :path => %r{^/apps/([^/]+)$}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, _ = request_params[:captures][:path]
+
+        with_mock_app(mock_data, app) do |app_data|
+          if request_params[:query].has_key?('app[name]')
+            app_data['name'] = request_params[:query]['app[name]']
+          end
+          if request_params[:query].has_key?('app[transfer_owner]')
+            email = request_params[:query]['app[transfer_owner]']
+            if collaborator = get_mock_collaborator(mock_data, app, email)
+              app_data['owner_email'] = email
+            end
+          end
+          if email && !collaborator
+            {
+              :body   => Heroku::API::OkJson.encode('error' => 'Only existing collaborators can receive ownership for an app'),
+              :status => 422
+            }
+          else
+            {
+              :body   => Heroku::API::OkJson.encode('name' => app_data['name']),
+              :status => 200
+            }
+          end
+        end
+      end
+
+      # stub PUT /apps/:app/status
+      Excon.stub(:method => :put, :path => %r{^/apps/([^/]+)/status}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, _ = request_params[:captures][:path]
+
+        with_mock_app(mock_data, app) do |app_data|
+          {
+            :body   => Heroku::API::OkJson.encode({}),
+            :status => 201
+          }
+        end
+      end
+
+    end
+  end
+end