azuki-api 0.0.2

data/lib/azuki/api/mock/domains.rb

@@ -0,0 +1,80 @@
+module Azuki
+  class API
+    module Mock
+
+      # stub DELETE /apps/:app/domains/:domain
+      Excon.stub(:expects => 200, :method => :delete, :path => %r{^/apps/([^/]+)/domains/([^/]+)$} ) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, domain, _ = request_params[:captures][:path]
+        domain = unescape(domain)
+        with_mock_app(mock_data, app) do |app_data|
+          if domain = get_mock_app_domain(mock_data, app, domain)
+            mock_data[:domains][app].delete(domain)
+            {
+              :body   => {},
+              :status => 200
+            }
+          else
+            {
+              :body   => 'Domain not found.',
+              :status => 404
+            }
+          end
+        end
+      end
+
+      # stub DELETE /apps/:app/domains/:domain
+      Excon.stub(:expects => 200, :method => :delete, :path => %r{^/apps/([^/]+)/domains$} ) 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[:domains][app] = []
+          {
+            :body   => "",
+            :status => 200
+          }
+        end
+      end
+
+      # stub DELETE /apps//domains/:domain
+      Excon.stub({:method => :delete, :path => %r{^/apps//domains/([^/]+)$} }, {:status => 404})
+
+      # stub GET /apps/:app/domains
+      Excon.stub(:expects => 200, :method => :get, :path => %r{^/apps/([^/]+)/domains$} ) 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   => Azuki::API::OkJson.encode(mock_data[:domains][app]),
+            :status => 200
+          }
+        end
+      end
+
+      # stub POST /apps/:app/domains
+      Excon.stub(:expects => 201, :method => :post, :path => %r{^/apps/([^/]+)/domains$} ) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, _ = request_params[:captures][:path]
+        domain = request_params[:query]['domain_name[domain]']
+        with_mock_app(mock_data, app) do |app_data|
+          unless get_mock_app_domain(mock_data, app, domain)
+            mock_data[:domains][app] << {
+              'app_id'      => app_data['id'],
+              'base_domain' => domain.split('.')[-2..-1].join('.'),
+              'created_at'  => timestamp,
+              'domain'      => domain,
+              'default'     => nil,
+              'id'          => rand(999999),
+              'updated_at'  => timestamp
+            }
+          end
+          {
+            :body   => Azuki::API::OkJson.encode('domain' => domain),
+            :status => 201
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/azuki/api/mock/features.rb

@@ -0,0 +1,120 @@
+module Azuki
+  class API
+    module Mock
+
+      # stub DELETE /features/:feature
+      Excon.stub(:expects => 200, :method => :delete, :path => %r{^/features/([^/]+)$}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app = request_params[:query].has_key?('app') && request_params[:query]['app']
+        feature, _ = request_params[:captures][:path]
+        if !app || get_mock_app(mock_data, app)
+          # app found
+          if feature_data = get_mock_feature(mock_data, feature)
+            feature_data = feature_data.merge('enabled' => true)
+            # feature exists
+            case feature_data['kind']
+            when 'app'
+              mock_data[:features][:app][app].delete(feature_data)
+              {
+                :body   => Azuki::API::OkJson.encode(feature_data.merge('enabled' => false)),
+                :status => 200
+              }
+            when 'user'
+              mock_data[:features][:user].delete(feature_data.merge('enabled' => false))
+              {
+                :body   => Azuki::API::OkJson.encode(feature_data),
+                :status => 200
+              }
+            end
+          else
+            # feature does not exist
+            {
+              :body   => Azuki::API::OkJson.encode({'error' => "Feature not found."}),
+              :status => 404
+            }
+          end
+        else
+          {
+            :body   => 'Feature not enabled.',
+            :status => 422
+          }
+        end
+      end
+
+      # stub GET /features
+      Excon.stub(:expects => 200, :method => :get, :path => %r|^/features$|) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        {
+          :body   => File.read("#{File.dirname(__FILE__)}/cache/get_features.json"),
+          :status => 200
+        }
+      end
+
+      # stub GET /features/:feature
+      Excon.stub(:expects => 200, :method => :get, :path => %r{^/features/([^/]+)}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        feature, _ = request_params[:captures][:path]
+        if feature_data = get_mock_feature(mock_data, feature)
+          {
+            :body   => Azuki::API::OkJson.encode(feature_data),
+            :status => 200
+          }
+        else
+          # feature does not exist
+          {
+            :body   => Azuki::API::OkJson.encode({'error' => "Feature not found."}),
+            :status => 404
+          }
+        end
+      end
+
+      # stub POST /features/:feature
+      Excon.stub(:expects => [200, 201], :method => :post, :path => %r{^/features/([^/]+)$}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app = request_params[:query].has_key?('app') && request_params[:query]['app']
+        feature, _ = request_params[:captures][:path]
+        if !app || get_mock_app(mock_data, app)
+          # app found
+          if feature_data = get_mock_feature(mock_data, feature)
+            feature_data = feature_data.merge('enabled' => true)
+            # feature exists
+            case feature_data['kind']
+            when 'app'
+              status = if mock_data[:features][:app][app].include?(feature_data)
+                200
+              else
+                mock_data[:features][:app][app] << feature_data
+                201
+              end
+              {
+                :body   => Azuki::API::OkJson.encode(feature_data),
+                :status => status
+              }
+            when 'user'
+              status = if mock_data[:features][:user].include(feature_data)
+                200
+              else
+                mock_data[:features][:user] << feature_data
+                201
+              end
+              {
+                :body   => '',
+                :status => status
+              }
+            end
+          else
+            # feature does not exist
+            {
+              :body   => Azuki::API::OkJson.encode({'error' => "Feature not found."}),
+              :status => 404
+            }
+          end
+        else
+          # app not found
+          Azuki::API::Mock::APP_NOT_FOUND
+        end
+      end
+
+    end
+  end
+end

data/lib/azuki/api/mock/keys.rb

@@ -0,0 +1,46 @@
+module Azuki
+  class API
+    module Mock
+
+      # stub DELETE /user/keys/:key
+      Excon.stub(:expects => 200, :method => :delete, :path => %r{^/user/keys/([^/]+)}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        key, _ = request_params[:captures][:path]
+        key = unescape(key)
+        if key_data = get_mock_key(mock_data, key)
+          mock_data[:keys].delete(key_data)
+          { :status => 200 }
+        else
+          { :body => "Key not found.", :status => 404 }
+        end
+      end
+
+      # stub DELETE /user/keys
+      Excon.stub(:expects => 200, :method => :delete, :path => %r{^/user/keys$}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        mock_data[:keys] = []
+        { :status => 200 }
+      end
+
+      # stub GET /user/keys
+      Excon.stub(:expects => 200, :method => :get, :path => %r{^/user/keys}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        {
+          :body   => Azuki::API::OkJson.encode(mock_data[:keys]),
+          :status => 200
+        }
+      end
+
+      # stub POST /user/keys
+      Excon.stub(:expects => 200, :method => :post, :path => %r{^/user/keys}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        mock_data[:keys] |= [{
+          'email'     => 'email@example.com',
+          'contents'  => request_params[:body]
+        }]
+        { :status => 200 }
+      end
+
+    end
+  end
+end

data/lib/azuki/api/mock/login.rb

@@ -0,0 +1,22 @@
+module Azuki
+  class API
+    module Mock
+
+      # stub POST /login
+      Excon.stub(:expects => 200, :method => :post, :path => '/login') do |params|
+        request_params, mock_data = parse_stub_params(params)
+        {
+          :body   => {
+            'api_key'     => SecureRandom.hex(20),
+            'email'       => 'email@example.com',
+            'id'          => '123456@users.azukiapp.com',
+            'verified'    => true,
+            'verified_at' => timestamp
+          },
+          :status => 200
+        }
+      end
+
+    end
+  end
+end

data/lib/azuki/api/mock/logs.rb

@@ -0,0 +1,20 @@
+module Azuki
+  class API
+    module Mock
+
+      # stub GET /apps/:app/logs
+      Excon.stub(:expects => 200, :method => :get, :path => %r{^/apps/([^/]+)/logs}) do |params|
+        request_params, mock_data = parse_stub_params(params)
+        app, _ = request_params[:captures][:path]
+        with_mock_app(mock_data, app) do
+          uuid = [SecureRandom.hex(4), SecureRandom.hex(2), SecureRandom.hex(2), SecureRandom.hex(2), SecureRandom.hex(6)].join('-')
+          {
+            :body   => "https://logplex.azukiapp.com/sessions/#{uuid}?srv=#{Time.now.to_i}",
+            :status => 200
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/azuki/api/mock/processes.rb

@@ -0,0 +1,198 @@
+module Azuki
+  class API
+    module Mock
+
+    # stub GET /apps/:app/ps
+    Excon.stub(:expects => 200, :method => :get, :path => %r{^/apps/([^/]+)/ps}) 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   => Azuki::API::OkJson.encode(get_mock_processes(mock_data, app)),
+          :status => 200
+        }
+      end
+    end
+
+    # stub POST /apps/:app/ps
+    Excon.stub(:expects => 200, :method => :post, :path => %r{^/apps/([^/]+)/ps\/?$}) do |params|
+      request_params, mock_data = parse_stub_params(params)
+      app, _ = request_params[:captures][:path]
+      with_mock_app(mock_data, app) do |app_data|
+        unless attached = request_params[:query].has_key?('attach') && request_params[:query]['attach'].to_s == 'true'
+          type = 'Ps'
+        end
+        command  = request_params[:query].has_key?('command') && request_params[:query]['command']
+        rendezvous_url = if attached
+          "s1.runtime.azukiapp.com:5000/#{SecureRandom.hex(32)}"
+        end
+        max_run_id = mock_data[:ps][app].map { |process| process['process'].split('run.').last.to_i}.max
+        data = {
+          'action'          => 'complete',
+          'attached'        => attached,
+          'command'         => command,
+          'elapsed'         => 0,
+          'pretty_state'    => 'completed for 0s',
+          'process'         => "run.#{max_run_id + 1}",
+          'rendezvous_url'  => rendezvous_url,
+          'slug'            => 'NONE',
+          'state'           => 'created',
+          'transitioned_at' => timestamp,
+          'type'            => type,
+          'upid'            => rand(99999999).to_s
+        }
+        mock_data[:ps][app] << data
+        {
+          :body   => Azuki::API::OkJson.encode(data),
+          :status => 200,
+        }
+      end
+    end
+
+    # stub POST /apps/:app/ps/restart
+    Excon.stub(:expects => 200, :method => :post, :path => %r{^/apps/([^/]+)/ps/restart}) do |params|
+      request_params, mock_data = parse_stub_params(params)
+      app, _ = request_params[:captures][:path]
+      with_mock_app(mock_data, app) do |app_data|
+        ps = request_params[:query].has_key?('ps') && request_params[:query]['ps']
+        type  = request_params[:query].has_key?('type') && request_params[:query]['type']
+        if !ps && !type
+          mock_data[:ps][app].select {|process| process['state'] != 'complete'}.each do |process|
+            process['transitioned_at'] = timestamp
+          end
+        elsif ps
+          mock_data[:ps][app].select {|process| process['process'] == 'ps' && process['state'] != 'complete'}.each do |process|
+            process['transitioned_at'] = timestamp
+          end
+        elsif type
+          mock_data[:ps][app].select {|process| process['process'] =~ %r{^#{type}\.\d+} && process['state'] != 'complete'}.each do |process|
+            process['transitioned_at'] = timestamp
+          end
+        end
+        {
+          :body   => 'ok',
+          :status => 200
+        }
+      end
+    end
+
+    # stub POST /apps/:app/ps/scale
+    Excon.stub(:expects => 200, :method => :post, :path => %r{^/apps/([^/]+)/ps/scale}) do |params|
+      request_params, mock_data = parse_stub_params(params)
+      app, _ = request_params[:captures][:path]
+      with_mock_app(mock_data, app) do |app_data|
+        type = request_params[:query].has_key?('type') && request_params[:query]['type']
+        qty = request_params[:query].has_key?('qty') && request_params[:query]['qty']
+        if app_data['stack'] == 'cedar'
+          if type == 'web'
+            current_qty = mock_data[:ps][app].count {|process| process['process'] =~ %r{^web\.\d+}}
+
+            new_qty = case qty
+            when /[+-]\d+/
+              current_qty + qty.to_i
+            else
+              qty.to_i
+            end
+
+            if new_qty >= current_qty
+              (new_qty - current_qty).times do
+                max_web_id = mock_data[:ps][app].map {|process| process['process'].split('web.').last.to_i}.max
+                data = mock_data[:ps][app].first.merge({
+                  'process'         => "web.#{max_web_id + 1}",
+                  'transitioned_at' => timestamp,
+                  'upid'            => rand(99999999).to_s
+                })
+                mock_data[:ps][app] << data
+              end
+            elsif new_qty < current_qty
+              (current_qty - new_qty).times do
+                max_web_id = mock_data[:ps][app].map {|process| process['process'].split('web.').last.to_i}.max
+                process = mock_data[:ps][app].detect {|process| process['process'] == "web.#{max_web_id}"}
+                mock_data[:ps][app].delete(process)
+              end
+            end
+            {
+              :body   => new_qty.to_s,
+              :status => 200
+            }
+          else
+            {
+              :body   => Azuki::API::OkJson.encode('error' => "No such type as #{type}") ,
+              :status => 422
+            }
+          end
+        else
+          {
+            :body   => Azuki::API::OkJson.encode('error' => "That feature is not available on this app's stack"),
+            :status => 422
+          }
+        end
+      end
+    end
+
+    # stub POST /apps/:app/ps/stop
+    Excon.stub(:expects => 200, :method => :post, :path => %r{^/apps/([^/]+)/ps/stop}) do |params|
+      request_params, mock_data = parse_stub_params(params)
+      app, _ = request_params[:captures][:path]
+      with_mock_app(mock_data, app) do |app_data|
+        ps = request_params[:query].has_key?('ps') && request_params[:query]['ps']
+        type  = request_params[:query].has_key?('type') && request_params[:query]['type']
+        if !ps && !type
+          {
+            :body   => Azuki::API::OkJson.encode({'error' => 'Missing process argument'}),
+            :status => 422
+          }
+        else
+          {
+            :body   => 'ok',
+            :status => 200
+          }
+        end
+      end
+    end
+
+    # stub PUT /apps/:app/dynos
+    Excon.stub(:expects => 200, :method => :put, :path => %r{^/apps/([^/]+)/dynos}) do |params|
+      request_params, mock_data = parse_stub_params(params)
+      app, _ = request_params[:captures][:path]
+      with_mock_app(mock_data, app) do |app_data|
+        dynos = request_params[:query].has_key?('dynos') && request_params[:query]['dynos'].to_i
+        unless app_data['stack'] == 'cedar'
+          app_data['dynos'] = dynos
+          {
+            :body   => Azuki::API::OkJson.encode({'name' => app, 'dynos' => dynos}),
+            :status => 200
+          }
+        else
+          {
+            :body   => Azuki::API::OkJson.encode({'error' => "For Cedar apps, use `azuki scale web=#{dynos}`"}),
+            :status => 422
+          }
+        end
+      end
+    end
+
+    # stub PUT /apps/:app/workers
+    Excon.stub(:expects => 200, :method => :put, :path => %r{^/apps/([^/]+)/workers}) do |params|
+      request_params, mock_data = parse_stub_params(params)
+      app, _ = request_params[:captures][:path]
+      with_mock_app(mock_data, app) do |app_data|
+        workers = request_params[:query].has_key?('workers') && request_params[:query]['workers'].to_i
+        unless app_data['stack'] == 'cedar'
+          app_data['workers'] = workers
+          {
+            :body   => Azuki::API::OkJson.encode({'name' => app, 'workers' => workers}),
+            :status => 200
+          }
+        else
+          {
+            :body   => Azuki::API::OkJson.encode({'error' => "For Cedar apps, use `azuki scale worker=#{workers}`"}),
+            :status => 422
+          }
+        end
+      end
+    end
+
+    end
+  end
+end