kensa 1.2.0rc7 → 1.2.0

data/test.rb

@@ -1 +0,0 @@
-puts ARGV

data/test/deprovision_test.rb

@@ -1,30 +0,0 @@
-$:.unshift(File.expand_path("../..",__FILE__))
-require 'test/lib/dependencies'
-class DeprovisionTest < Test::Unit::TestCase
-
-  def setup
-    super
-    @params = {}
-  end
-
-  def deprovision(auth = nil)
-    delete "/heroku/resources/123", auth
-  end
-
-  def test_working_deprovision_call
-    response = deprovision
-    assert_equal 200, response.code, "Expects a 200 - OK response/status code when successfully deprovisioned."
-  end
-
-  def test_detects_missing_auth
-    response = deprovision(auth = false)
-    assert_equal 401, response.code, "Provisioning request should require authentication."
-
-    response = deprovision(auth = [manifest["id"]+"a", manifest["api"]["password"]])
-    assert_equal 401, response.code, "Provisioning request appears to allow any username, should require '#{manifest["id"]}'."
-
-    response = deprovision(auth = [manifest["id"], manifest["api"]["password"]+"a"])
-    assert_equal 401, response.code, "Provisioning request appears to allow any password, should require '#{manifest["api"]["password"]}'."
-  end
-
-end

data/test/lib/dependencies.rb

@@ -1,12 +0,0 @@
-require 'test/unit'
-require 'artifice'
-require 'rest-client'
-require 'yajl'
-require 'lib/heroku/kensa/manifest'
-%w{response http formatter}.each do |lib|
-  require "test/lib/#{lib}"
-end
-
-class Test::Unit::TestCase
-  include Heroku::Kensa::HTTPTest
-end

data/test/lib/formatter.rb

@@ -1,84 +0,0 @@
-require 'test/unit'
-require 'test/unit/ui/console/testrunner'
-
-def format_kensa_test_name(name)
-  name.sub(/\Atest_/,"").match(/\A([^\(]*)/)[1].gsub("_", " ")
-end
-
-module Test
-  module Unit
-    class TestCase
-      alias_method :add_error_with_connection_exception, :add_error
-      alias_method :add_failure_with_connection_exception, :add_failure
-
-      private
-      def add_error(exception)
-        if exception.is_a? Heroku::Kensa::UserError
-          @test_passed = false
-          @_result.add_failure(Failure.new(name, filter_backtrace(caller()), exception.message))
-        else
-          add_error_with_connection_exception(exception)
-        end
-      end
-    end
-
-    class Failure
-      def long_display
-        name = format_kensa_test_name(@test_name)
-        "#{name} - FAILED: #@message"
-      end
-    end
-
-    class Error
-      def long_display
-        backtrace = filter_backtrace(@exception.backtrace).join("\n    ")
-        name = format_kensa_test_name(@test_name)
-        "#{@exception.class.name} in #{name}:\n#{message}\n    #{backtrace}"
-      end
-    end
-
-    module UI
-      module Console
-        class TestRunner
-
-          alias_method :test_started_old, :test_started
-
-          def add_fault(fault)
-            @faults << fault
-            @already_outputted = true
-          end
-
-          def test_started(name)
-            if name =~ /\((.*)::([^\)]*)/
-              ctx, should = [$1, $2]
-            end
-            unless ctx.nil? or should.nil?
-              if ctx != @ctx
-                nl
-                output("#{ctx}:")
-              end
-              @ctx = ctx
-              @current_test_text = " ==> #{should}"
-            else
-              test_started_old(name)
-            end
-          end
-
-          def test_finished(name)
-            @current_test_text = name.sub(/\Atest_/,"").match(/\A([^\(]*)/)[1].gsub("_", " ")
-            if fault = @faults.find {|f| f.test_name == name}
-              fault_type = fault.is_a?(Test::Unit::Failure) ? "FAILED" : "ERROR!"
-              # NOTE -- Concatenation because "\e[0m]" does funky stuff.
-              output("[\e[0;31m#{fault_type}\e[0m" + "] #{@current_test_text}.")
-            else
-              output("[  \e[0;32mOK\e[0m  ] #{@current_test_text}.")
-            end
-            @already_outputted = false
-          end
-
-        end
-      end
-    end
-  end
-end
-

data/test/lib/http.rb

@@ -1,60 +0,0 @@
-module Heroku::Kensa::HTTPTest
-  def make_token(id, salt, timestamp)
-    Digest::SHA1.hexdigest([id, salt, timestamp].join(':'))
-  end
-
-  def provider_request(meth, path, params = {}, auth_credentials = nil)
-    if auth_credentials.nil?
-      auth_credentials = [manifest["id"], manifest["api"]["password"]]
-    end
-    if path =~ /http/
-      uri = URI.parse(path)
-    else
-      uri = URI.parse(base_url)
-      uri.path = path
-    end
-    if auth_credentials
-      uri.userinfo = auth_credentials
-    end
-    opts = meth == :get ? { :params => params } : params
-    response = RestClient.send(meth, "#{uri.to_s}", opts)
-    Response.new(response.code, response.body, response.cookies)
-  rescue Errno::ECONNREFUSED
-    raise UserError.new("Unable to connect to your API.")
-  rescue RestClient::Forbidden
-    Response.new(403)
-  rescue RestClient::Unauthorized
-    Response.new(401)
-  rescue RestClient::InternalServerError
-    raise UserError.new("HTTP 500 Internal Server Error")
-  end
-
-  def get(path, params = {})
-    provider_request(:get, path, params, auth = false)
-  end
-
-  def delete(path, auth_credentials = nil)
-    provider_request(:delete, path, params = nil, auth_credentials)
-  end
-
-  def post(path, params = {}, auth_credentials = nil)
-    provider_request(:post, path, params, auth_credentials)
-  end
-
-  def put(path, params = {}, auth_credentials = nil)
-    provider_request(:put, path, params, auth_credentials)
-  end
-
-  def manifest
-    return @manifest if @manifest
-    @manifest ||= $manifest || Heroku::Kensa::Manifest.new.skeleton
-  end
-
-  def base_url
-    if manifest["api"]["test"].is_a?(Hash)
-      manifest["api"]["test"]["base_url"].chomp("/")
-    else
-      manifest["api"]["test"].chomp("/")
-    end
-  end
-end

data/test/lib/response.rb

@@ -1,12 +0,0 @@
-Response = Struct.new(:code, :body, :cookies) do
-  def json_body
-    Yajl::Parser.parse(self.body)
-  rescue Yajl::ParseError
-    if !self.body || self.body.empty?
-      raise Heroku::Kensa::UserError.new("response body empty")
-    else
-      raise Heroku::Kensa::UserError.new("Could not parse json: #{self.body}")
-    end
-  end
-end
-

data/test/manifest_generation_test.rb

@@ -1,32 +0,0 @@
-$:.unshift(File.expand_path("../..",__FILE__))
-require 'test/helper'
-class ManifestGenerationTest < Test::Unit::TestCase
-  include Heroku::Kensa
-
-  def setup
-    super
-    @manifest = Manifest.new
-  end
-
-  def test_generates_a_new_sso_salt_every_time
-    assert @manifest.skeleton['api']['sso_salt'] != Manifest.new.skeleton['api']['sso_salt']
-  end
-
-  def test_generates_a_new_password_every_time
-    assert @manifest.skeleton['api']['password'] != Manifest.new.skeleton['api']['password']
-  end
-end
-
-class ManifestGenerationWithoutSSOTest < Test::Unit::TestCase
-  include Heroku::Kensa
-
-  def setup
-    super
-    options = { :sso => false }
-    @manifest = Manifest.new 'test.txt', options
-  end
-
-  def test_exclude_sso_salt
-    assert_nil @manifest.skeleton['api']['sso_salt']
-  end
-end

data/test/plan_change_test.rb

@@ -1,30 +0,0 @@
-$:.unshift(File.expand_path("../..",__FILE__))
-require 'test/lib/dependencies'
-class PlanChangeTest < Test::Unit::TestCase
-
-  def setup
-    super
-    @params = { :plan => "new_plan" }
-  end
-
-  def plan_change(auth = nil, params = @params)
-    response = put "/heroku/resources/123", params, auth
-  end
-
-  def test_working_plan_change_call
-    response = plan_change
-    assert_equal 200, response.code, "Expected a 200 response code on successful plan change."
-  end
-
-  def test_detects_missing_auth
-    response = plan_change(auth = false)
-    assert_equal 401, response.code, "Provisioning request should require authentication."
-
-    response = plan_change(auth = [manifest["id"]+"a", manifest["api"]["password"]])
-    assert_equal 401, response.code, "Provisioning request appears to allow any username, should require '#{manifest["id"]}'."
-
-    response = plan_change(auth = [manifest["id"], manifest["api"]["password"]+"a"])
-    assert_equal 401, response.code, "Provisioning request appears to allow any password, should require '#{manifest["api"]["password"]}'."
-  end
-
-end

data/test/provision_test.rb

@@ -1,84 +0,0 @@
-$:.unshift(File.expand_path("../..",__FILE__))
-require 'test/lib/dependencies'
-class ProvisionTest < Test::Unit::TestCase
-
-  def setup
-    super
-    @params = {}
-  end
-
-  def provision(auth = nil, params = @params)
-    post "/heroku/resources", params, auth
-  end
-
-  def test_working_provision_call
-    response = provision
-    assert_equal 201, response.code, "Expects a 201 - Created response/status code when successfully provisioned."
-  end
-
-  def test_allows_the_definition_of_a_custom_provisioning_endpoint
-    #Artifice.activate_with(KensaServer.new)
-    #@data['api']['test'] = {
-    #  "base_url" => "https://example.org/providers/provision",
-    #  "sso_url"  => "https://example.org/sso"
-    #}
-    #assert_valid
-  end
-
-  def test_expects_a_valid_json_response
-    response = provision
-    assert response.json_body, "Expects a valid JSON object as response body."
-  end
-
-  def test_detects_missing_id
-    response = provision
-    assert response.json_body["id"], "Expects JSON response to contain the Provider's unique ID for this app."
-    assert response.json_body["id"].to_s.strip != "", "Expects JSON response to contain the Provider's unique ID for this app."
-  end
-
-  def test_provides_app_config
-    response = provision
-    assert response.json_body["config"].is_a?(Hash), "Expects JSON response to contain a hash of config variables."
-  end
-
-  def test_all_config_values_are_strings
-    response = provision
-    response.json_body["config"].each do |k,v|
-      assert k.is_a?(String), "Expect all config names to be strings ('#{k}' is not)."
-      assert v.is_a?(String), "Expect all config values to be strings ('#{v}' is not)."
-    end
-  end
-
-  def test_all_config_vars_are_defined_in_the_manifest
-    response = provision
-    response.json_body["config"].each do |k,v|
-      assert manifest["api"]["config_vars"].include?(k), "Only config vars defined in the manfiest can be set ('#{k}' is not)."
-    end
-  end
-
-  def test_all_config_url_values_are_valid
-    response = provision
-    response.json_body["config"].each do |k,v|
-      next unless k =~ /_URL\z/
-      begin
-        uri = URI.parse(v)
-        assert uri.host, "#{v} is not a valid URI - missing host"
-        assert uri.scheme, "#{v} is not a valid URI - missing scheme"
-      rescue URI::InvalidURIError
-        assert false, "#{v} is not a valud URI"
-      end
-    end
-  end
-
-  def test_detects_missing_auth
-    response = provision(auth = false)
-    assert_equal 401, response.code, "Provisioning request should require authentication."
-
-    response = provision(auth = [manifest["id"]+"a", manifest["api"]["password"]])
-    assert_equal 401, response.code, "Provisioning request appears to allow any username, should require '#{manifest["id"]}'."
-
-    response = provision(auth = [manifest["id"], manifest["api"]["password"]+"a"])
-    assert_equal 401, response.code, "Provisioning request appears to allow any password, should require '#{manifest["api"]["password"]}'."
-  end
-
-end

data/test/resources/provider_server.rb

@@ -1,81 +0,0 @@
-require 'sinatra'
-require 'json'
-
-class ProviderServer < Sinatra::Base
-  set :views, File.dirname(__FILE__) + "/views"
-
-  def initialize(manifest = nil)
-    @manifest = manifest
-    super
-  end
-
-  helpers do
-    def unauthorized!(status=403)
-      halt status, "Not authorized\n"
-    end
-
-    def check_timestamp!
-      unauthorized! if params[:timestamp].to_i < (Time.now-60*2).to_i
-    end
-
-    def check_token!
-      salt = @manifest && @manifest['api']["sso_salt"]
-      token = Digest::SHA1.hexdigest([params[:id], salt, params[:timestamp]].join(':'))
-      unauthorized! if params[:token] != token
-    end
-
-    def authenticate!
-      unless auth_heroku?
-        response['WWW-Authenticate'] = %(Basic realm="Kensa Test Server")
-        unauthorized!(401)
-      end
-    end
-
-    def auth_heroku?
-      auth =  Rack::Auth::Basic::Request.new(request.env)
-      return false unless auth.provided? && auth.basic? && auth.credentials
-      if @manifest
-        auth.credentials == [@manifest["id"], @manifest["api"]["password"]]
-      else
-        auth.credentials == ['myaddon', 'secret']
-      end
-    end
-  end
-
-  delete '/heroku/resources/:id' do
-    authenticate!
-    status 200
-  end
-
-  put '/heroku/resources/:id' do
-    authenticate!
-    status 200
-  end
-
-  post '/heroku/resources' do
-    authenticate!
-    status 201
-    { "id" => 52343.to_s,
-      "config" => {
-        "MYADDON_USER" => "1",
-        "MYADDON_URL" => "http://host.example.org/"
-      }
-    }.to_json
-  end
-
-  get '/heroku/resources/:id' do
-    check_timestamp!
-    check_token!
-    response.set_cookie('heroku-nav-data', params['nav-data'])
-    session[:heroku] = true
-    haml :index
-  end
-
-  post '/sso/login' do
-    check_timestamp!
-    check_token!
-    response.set_cookie('heroku-nav-data', params['nav-data'])
-    session[:heroku] = true
-    haml :index
-  end
-end

data/test/resources/views/index.haml

@@ -1,6 +0,0 @@
-%html
-  %body
-    - if session[:heroku]
-      #heroku-header
-        %h1 Heroku
-    %h1 Sample Addon