kensa 1.2.0rc7 → 1.2.0

data/.gitignore

@@ -2,4 +2,4 @@ addon-manifest.json
 pkg/
 .rvmrc
 tags
-bundle/
+test_log.txt

data/Gemfile

@@ -1,6 +1,7 @@
-source "http://rubygems.org"
+source :rubygems
 gemspec
-group :development do
-  gem 'ruby-debug', :platform => :mri_18
-  gem 'ruby-debug19', :platform => :mri_19
+gem 'rake'
+group :development do 
+  gem 'ruby-debug',   :platforms => [:ruby_18]
+  gem 'ruby-debug19', :platforms => [:ruby_19]
 end

data/Gemfile.lock

@@ -1,27 +1,23 @@
 PATH
   remote: .
   specs:
-    kensa (1.2.0rc7)
-      artifice (~> 0.6.0)
-      launchy (~> 2.0.5)
+    kensa (1.2.0)
+      launchy (>= 0.3.2)
       mechanize (~> 1.0.0)
-      rest-client (~> 1.6.7)
-      term-ansicolor (~> 1.0.6)
-      test-unit (~> 1.2.3)
-      yajl-ruby (~> 0.8.3)
+      rest-client (>= 1.4.0, < 1.7.0)
+      term-ansicolor (~> 1.0)
+      yajl-ruby (~> 0.6)
 
 GEM
   remote: http://rubygems.org/
   specs:
     addressable (2.2.6)
     archive-tar-minitar (0.5.2)
-    artifice (0.6)
-      rack-test
     columnize (0.3.4)
-    haml (3.1.3)
-    hoe (2.12.3)
-      rake (~> 0.8)
-    json (1.6.1)
+    contest (0.1.3)
+    fakefs (0.4.0)
+    haml (3.1.2)
+    json (1.5.3)
     launchy (2.0.5)
       addressable (~> 2.2.6)
     linecache (0.43)
@@ -29,15 +25,13 @@ GEM
       ruby_core_source (>= 0.1.4)
     mechanize (1.0.0)
       nokogiri (>= 1.2.1)
-    mime-types (1.16)
+    mime-types (1.17.2)
     nokogiri (1.5.0)
-    rack (1.3.3)
-    rack-test (0.6.1)
-      rack (>= 1.0)
-    rake (0.9.2)
+    rack (1.3.2)
+    rake (0.9.2.2)
     rest-client (1.6.7)
       mime-types (>= 1.16)
-    rr (1.0.4)
+    rr (1.0.3)
     ruby-debug (0.10.4)
       columnize (>= 0.1)
       ruby-debug-base (~> 0.10.4.0)
@@ -57,9 +51,7 @@ GEM
       rack (~> 1.1)
       tilt (>= 1.2.2, < 2.0)
     term-ansicolor (1.0.7)
-    test-unit (1.2.3)
-      hoe (>= 1.5.1)
-    tilt (1.3.3)
+    tilt (1.3.2)
     timecop (0.3.5)
     yajl-ruby (0.8.3)
 
@@ -67,12 +59,14 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  artifice (~> 0.6)
-  haml (~> 3.1.3)
+  contest
+  fakefs
+  haml
   json
   kensa!
-  rr (~> 1.0.4)
+  rake
+  rr
   ruby-debug
   ruby-debug19
-  sinatra (~> 1.2.6)
-  timecop (~> 0.3.5)
+  sinatra (>= 0.9)
+  timecop (>= 0.3.5)

data/README.md

@@ -24,6 +24,6 @@ http://provider.heroku.com/resources/technical/build/provisioning
 
 ## Meta #######################################################################
 
-Maintained by Glenn Gillen and Chris Continanza.
+Maintained by Pedro Belo.
 
 Released under the MIT license. http://github.com/heroku/kensa

data/Rakefile

@@ -1,12 +1,20 @@
-$:.unshift File.dirname(__FILE__)
-require "bundler/gem_tasks"
-
-desc 'Run all unit tests'
-task :test do
-  puts require "test/helper"
-  Dir["test/*_test.rb"].each do |test_file|
-    require test_file
-  end
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << '.'
+  t.verbose = true
+  t.test_files = FileList["test/*_test.rb"]
+end
+
+desc 'Start the server'
+task :start do
+  fork { exec "ruby test/resources/server.rb > test_log.txt 2>&1" }
+end
+
+desc 'Stop the server'
+task :stop do
+  system "ps -ax | grep test/resources/server.rb | grep -v grep | awk '{print $1}' | xargs kill"
 end
 
-task :default => :test
+task :default => [:start, :test, :stop]

data/bin/kensa

@@ -4,47 +4,28 @@ lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
 $LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
 
 require 'rubygems'
-require 'optparse'
 require 'heroku/kensa'
 require 'heroku/kensa/client'
 
 $stdout.sync = true
 
-options = {
-  :filename => 'addon-manifest.json',
-  :env      => "test",
-  :async    => false,
-}
-
-ARGV.options do |o|
-  o.on("-f file", "--file") {|filename| options[:filename] = filename }
-  o.on("--async") { options[:async] = true }
-  o.on("--production") { options[:env] = "production" }
-  o.on("--without-sso") { options[:sso] = false }
-  o.on("-h", "--help") { command = "help" }
-  o.on("-p plan", "--plan") { |plan| options[:plan] = plan }
-  o.on("-v", "--version") { options[:command] = "version" }
-  o.on("-t template", "--template")  { |t| options[:template] = t }
-  o.parse!
-end
-
 include Heroku::Kensa
 
 begin
   args = ARGV.dup
   ARGV.clear
-  Client.new(args, options).run!
-rescue Client::CommandFailed => e
-  puts "We're sorry, but #{e.message} "
-rescue Client::CommandInvalid
+  Client.new(args).run!
+rescue Client::CommandInvalid => e
+  puts e.message unless e.message.empty?
   abort File.read(__FILE__).split('__END__').last
 end
 
 __END__
 Usage: kensa [OPTIONS] command
        kensa init
-       kensa test <type> [arg1 arg2 ...]
-       kensa run <command> [arg1 arg1 ...]
+       kensa create <app_name> --template
+       kensa test   <type> [arg1 arg2 ...]
+       kensa run    <command> [arg1 arg1 ...]
 
 OPTIONS
 
@@ -66,16 +47,14 @@ OPTIONS
   --post
     Use HTTP POST for single sign-on instead of GET
 
-  -t, --template name    
-    Desired template to clone for create command from:
-    git://github.com/heroku/kensa-template-<name>
-    try sinatra, clojure, or node 
+  --template
+    Name of git template on github or full url of git repo.
 
 COMMANDS
 
   init            Creates a skeleton manifest
 
-  create <name>   Creates a skeleton application from --template
+  create <app>    Clone a git repo that contains a template add-on
 
   test <type>     Simulate call from Heroku (provision or deprovision)
 
@@ -103,3 +82,4 @@ TEST TYPES
 
   manifest
     Confirm that the manifest is valid.  Automatically runs before all tests.
+

data/kensa.gemspec

@@ -1,14 +1,16 @@
+# -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
 require "heroku/kensa/version"
 
 Gem::Specification.new do |s|
-  s.name = "kensa"
-  s.summary = "Tool to help Heroku add-on providers integrating their services"
-  s.description = "Kensa is a command-line tool to help add-on providers integrating their services with Heroku. It manages manifest files, and provides a TDD-like approach for programmers to test and develop their APIs."
-  s.email = "glenn@heroku.com"
-  s.homepage = "http://provider.heroku.com/resources"
-  s.authors = ["Blake Mizerany", "Pedro Belo", "Adam Wiggins", "Chris Continanza", "Glenn Gillen"]
-  s.version   = Heroku::Kensa::VERSION
+  s.name = %q{kensa}
+  s.version = Heroku::Kensa::VERSION
+  s.platform = Gem::Platform::RUBY
+
+  s.authors = ["Blake Mizerany", "Pedro Belo", "Adam Wiggins", 'Glenn Gillen', 'Chris Continanza']
+  s.default_executable = %q{kensa}
+  s.description = %q{Kensa is a command-line tool to help add-on providers integrating their services with Heroku. It manages manifest files, and provides a TDD-like approach for programmers to test and develop their APIs.}
+  s.email = %q{pedro@heroku.com}
 
   s.rubyforge_project = "kensa"
 
@@ -17,17 +19,22 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency('json', [">= 0"])
-  s.add_development_dependency('sinatra', ["~> 1.2.6"])
-  s.add_development_dependency('timecop', ["~> 0.3.5"])
-  s.add_development_dependency('rr', ["~> 1.0.4"])
-  s.add_development_dependency('artifice', ["~> 0.6"])
-  s.add_development_dependency('haml', ["~> 3.1.3"])
-  s.add_runtime_dependency('test-unit', ["~> 1.2.3"])
-  s.add_runtime_dependency('rest-client', ["~> 1.6.7"])
-  s.add_runtime_dependency('yajl-ruby', ["~> 0.8.3"])
-  s.add_runtime_dependency('term-ansicolor', ["~> 1.0.6"])
-  s.add_runtime_dependency('launchy', ["~> 2.0.5"])
-  s.add_runtime_dependency('mechanize', ["~> 1.0.0"])
-  s.add_runtime_dependency('artifice', ["~> 0.6.0"])
+  s.homepage = %q{http://provider.heroku.com/resources}
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Tool to help Heroku add-on providers integrating their services}
+
+  s.add_development_dependency(%q<contest>, [">= 0"])
+  s.add_development_dependency(%q<timecop>, [">= 0.3.5"])
+  s.add_development_dependency(%q<sinatra>, [">= 0.9"])
+  s.add_development_dependency(%q<json>, [">= 0"])
+  s.add_development_dependency(%q<contest>, [">= 0"])
+  s.add_development_dependency(%q<haml>, [">= 0"])
+  s.add_development_dependency(%q<rr>, [">= 0"])
+  s.add_development_dependency(%q<fakefs>, [">= 0"])
+  s.add_runtime_dependency(%q<rest-client>, ["< 1.7.0", ">= 1.4.0"])
+  s.add_runtime_dependency(%q<yajl-ruby>, ["~> 0.6"])
+  s.add_runtime_dependency(%q<term-ansicolor>, ["~> 1.0"])
+  s.add_runtime_dependency(%q<launchy>, [">= 0.3.2"])
+  s.add_runtime_dependency(%q<mechanize>, ["~> 1.0.0"])
 end
+

data/lib/heroku/kensa.rb

@@ -1,10 +1,8 @@
-require 'yajl'
-require 'mechanize'
-require 'socket'
-require 'timeout'
-require 'uri'
-base_path = File.dirname(__FILE__)
-%w{http manifest sso post_proxy}.each do |lib|
-  require "#{base_path}/kensa/#{lib}"
-end
 require 'heroku/kensa/version'
+require 'heroku/kensa/http'
+require 'heroku/kensa/manifest'
+require 'heroku/kensa/check'
+require 'heroku/kensa/sso'
+require 'heroku/kensa/post_proxy'
+require 'heroku/kensa/screen'
+require 'heroku/kensa/git'

data/lib/heroku/kensa/check.rb

@@ -0,0 +1,499 @@
+require 'yajl'
+require 'mechanize'
+require 'socket'
+require 'timeout'
+require 'uri'
+
+module Heroku
+  module Kensa
+    class Check
+      attr_accessor :screen, :data
+
+      class CheckError < StandardError ; end
+
+      def initialize(data, screen=NilScreen.new)
+        @data = data
+        @screen = screen
+      end
+
+      def env
+        @data.fetch(:env, 'test')
+      end
+
+      def test(msg)
+        screen.test msg
+      end
+
+      def check(msg)
+        screen.check(msg)
+        if yield
+          screen.result(true)
+        else
+          raise CheckError
+        end
+      end
+
+      def run(klass, data)
+        c = klass.new(data, screen)
+        instance_eval(&c)
+      end
+
+      def error(msg)
+        raise CheckError, msg
+      end
+
+      def call
+        call!
+        true
+      rescue CheckError => boom
+        screen.result(false)
+        screen.error boom.message if boom.message != boom.class.name
+
+        false
+      end
+
+      def to_proc
+        me = self
+        Proc.new { me.call! }
+      end
+
+      def url
+        if data['api'][env].is_a? Hash
+          base = data['api'][env]['base_url']
+          uri = URI.parse(base)
+          base.sub!(uri.query, '') if uri.query
+          base.sub(uri.path, '')
+        else
+          data['api'][env].chomp("/")
+        end
+      end
+    end
+
+
+    class ManifestCheck < Check
+
+      ValidPriceUnits = %w[month dyno_hour]
+
+      def call!
+        test "manifest id key"
+        check "if exists" do
+          data.has_key?("id")
+        end
+        check "is a string" do
+          data["id"].is_a?(String)
+        end
+        check "is not blank" do
+          !data["id"].empty?
+        end
+
+        test "manifest api key"
+        check "if exists" do
+          data.has_key?("api")
+        end
+        check "is a hash" do
+          data["api"].is_a?(Hash)
+        end
+        check "contains password" do
+          data["api"].has_key?("password") && data["api"]["password"] != ""
+        end
+        check "contains test url" do
+          data["api"].has_key?("test")
+        end
+        check "contains production url" do
+          data["api"].has_key?("production")
+        end
+        if data['api']['production'].is_a? Hash
+          check "production url uses SSL" do
+            data['api']['production']['base_url'] =~ /^https:/
+          end
+          check "sso url uses SSL" do
+            data['api']['production']['sso_url'] =~ /^https:/
+          end
+        else
+          check "production url uses SSL" do
+            data['api']['production'] =~ /^https:/
+          end
+        end
+        check "contains config_vars array" do
+          data["api"].has_key?("config_vars") && data["api"]["config_vars"].is_a?(Array)
+        end
+        check "containst at least one config var" do
+          !data["api"]["config_vars"].empty?
+        end
+        check "all config vars are uppercase strings" do
+          data["api"]["config_vars"].each do |k, v|
+            if k =~ /^[A-Z][0-9A-Z_]+$/
+              true
+            else
+              error "#{k.inspect} is not a valid ENV key"
+            end
+          end
+        end
+        check "all config vars are prefixed with the addon id" do
+          data["api"]["config_vars"].each do |k|
+            addon_key = data['id'].upcase.gsub('-', '_')
+            if k =~ /^#{addon_key}_/
+              true
+            else
+              error "#{k} is not a valid ENV key - must be prefixed with #{addon_key}_"
+            end
+          end
+        end
+        check "deprecated fields" do
+          if data["api"].has_key?("username")
+            error "username is deprecated: Please authenticate using the add-on id."
+          end
+          true
+        end
+      end
+    end
+
+
+    class ProvisionResponseCheck < Check
+
+      def call!
+        response = data[:provision_response]
+        test "response"
+
+        check "contains an id" do
+          response.is_a?(Hash) && response.has_key?("id")
+        end
+
+        screen.message " (id #{response['id']})"
+
+        if response.has_key?("config")
+          test "config data"
+          check "is a hash" do
+            response["config"].is_a?(Hash)
+          end
+
+          check "all config keys were previously defined in the manifest" do
+            response["config"].keys.each do |key|
+              error "#{key} is not in the manifest" unless data["api"]["config_vars"].include?(key)
+            end
+            true
+          end
+
+          check "all keys in the manifest are present" do
+            difference = data['api']['config_vars'] - response['config'].keys 
+            unless difference.empty?
+              verb = (difference.size == 1) ? "is" : "are"
+              error "#{difference.join(', ')} #{verb} missing from the manifest"
+            end
+            true
+          end
+
+          check "all config values are strings" do
+            response["config"].each do |k, v|
+              if v.is_a?(String)
+                true
+              else
+                error "the key #{k} doesn't contain a string (#{v.inspect})"
+              end
+            end
+          end
+
+          check "URL configs vars" do
+            response["config"].each do |key, value|
+              next unless key =~ /_URL$/
+              begin
+                uri = URI.parse(value)
+                error "#{value} is not a valid URI - missing host" unless uri.host
+                error "#{value} is not a valid URI - missing scheme" unless uri.scheme
+                error "#{value} is not a valid URI - pointing to localhost" if env == 'production' && uri.host == 'localhost'
+              rescue URI::Error
+                error "#{value} is not a valid URI"
+              end
+            end
+          end
+
+        end
+      end
+
+    end
+
+
+    class ApiCheck < Check
+      def base_path
+        if data['api'][env].is_a? Hash
+          URI.parse(data['api'][env]['base_url']).path
+        else
+          '/heroku/resources'
+        end
+      end
+
+      def heroku_id
+        "app#{rand(10000)}@kensa.heroku.com"
+      end
+
+      def credentials
+        [ data['id'], data['api']['password'] ]
+      end
+    end
+
+    class ProvisionCheck < ApiCheck
+      include HTTP
+
+      READLEN = 1024 * 10
+
+      def call!
+        json = nil
+        response = nil
+
+        code = nil
+        json = nil
+        callback = "http://localhost:7779/callback/999"
+        reader, writer = nil
+
+        payload = {
+          :heroku_id => heroku_id,
+          :plan => data[:plan] || 'test',
+          :callback_url => callback, 
+          :logplex_token => nil,
+          :options => {}
+        }
+
+        if data[:async]
+          reader, writer = IO.pipe
+        end
+
+        test "POST /heroku/resources"
+        check "response" do
+          if data[:async]
+            child = fork do
+              reader.close
+              server = TCPServer.open(7779)
+              client = server.accept
+              writer.write(client.readpartial(READLEN))
+              client.write("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")
+              client.close
+              writer.close
+            end
+            sleep(1)
+          end
+
+          code, json = post(credentials, base_path, payload)
+
+          if code == 200
+            # noop
+          elsif code == -1
+            error("unable to connect to #{url}")
+          else
+            error("expected 200, got #{code}")
+          end
+
+          true
+        end
+
+        if data[:async]
+          check "async response to PUT #{callback}" do
+            out = reader.readpartial(READLEN)
+            _, json = out.split("\r\n\r\n")
+          end
+        end
+
+        check "valid JSON" do
+          begin
+            response = Yajl::Parser.parse(json)
+          rescue Yajl::ParseError => boom
+            error boom.message
+          end
+          true
+        end
+
+        check "authentication" do
+          wrong_credentials = ['wrong', 'secret']
+          code, _ = post(wrong_credentials, base_path, payload)
+          error("expected 401, got #{code}") if code != 401
+          true
+        end
+
+        data[:provision_response] = response
+
+        run ProvisionResponseCheck, data
+      end
+
+    ensure
+      reader.close rescue nil
+      writer.close rescue nil
+    end
+
+
+    class DeprovisionCheck < ApiCheck
+      include HTTP
+
+      def call!
+        id = data[:id]
+        raise ArgumentError, "No id specified" if id.nil?
+
+        path = "#{base_path}/#{CGI::escape(id.to_s)}"
+
+        test "DELETE #{path}"
+        check "response" do
+          code, _ = delete(credentials, path, nil)
+          if code == 200
+            true
+          elsif code == -1
+            error("unable to connect to #{url}")
+          else
+            error("expected 200, got #{code}")
+          end
+        end
+
+        check "authentication" do
+          wrong_credentials = ['wrong', 'secret']
+          code, _ = delete(wrong_credentials, path, nil)
+          error("expected 401, got #{code}") if code != 401
+          true
+        end
+
+      end
+
+    end
+
+
+    class PlanChangeCheck < ApiCheck
+      include HTTP
+
+      def call!
+        id = data[:id]
+        raise ArgumentError, "No id specified" if id.nil?
+
+        new_plan = data[:plan]
+        raise ArgumentError, "No plan specified" if new_plan.nil?
+
+        path = "#{base_path}/#{CGI::escape(id.to_s)}"
+        payload = {:plan => new_plan, :heroku_id => heroku_id}
+
+        test "PUT #{path}"
+        check "response" do
+          code, _ = put(credentials, path, payload)
+          if code == 200
+            true
+          elsif code == -1
+            error("unable to connect to #{url}")
+          else
+            error("expected 200, got #{code}")
+          end
+        end
+
+        check "authentication" do
+          wrong_credentials = ['wrong', 'secret']
+          code, _ = put(wrong_credentials, path, payload)
+          error("expected 401, got #{code}") if code != 401
+          true
+        end
+      end
+    end
+
+
+    class SsoCheck < ApiCheck
+      include HTTP
+
+      def agent
+        @agent ||= Mechanize.new
+      end
+
+      def mechanize_get
+        if @sso.POST?
+          page = agent.post(@sso.post_url, @sso.query_params)
+        else
+          page = agent.get(@sso.get_url)
+        end
+        return page, 200
+      rescue Mechanize::ResponseCodeError => error
+        return nil, error.response_code.to_i
+      rescue Errno::ECONNREFUSED
+        error("connection refused to #{url}")
+      end
+
+      def check(msg)
+        @sso = Sso.new(data)
+        super
+      end
+
+      def call!
+        error("need an sso salt to perform sso test") unless data['api']['sso_salt']
+
+        sso  = Sso.new(data)
+        verb = sso.POST? ? 'POST' : 'GET'
+        test "#{verb} #{sso.path}"
+
+        check "validates token" do
+          @sso.token = 'invalid'
+          page, respcode = mechanize_get 
+          error("expected 403, got #{respcode}") unless respcode == 403
+          true
+        end
+
+        check "validates timestamp" do
+          @sso.timestamp = (Time.now - 60*6).to_i
+          page, respcode = mechanize_get
+          error("expected 403, got #{respcode}") unless respcode == 403
+          true
+        end
+
+        page_logged_in = nil
+        check "logs in" do
+          page_logged_in, respcode = mechanize_get 
+          error("expected 200, got #{respcode}") unless respcode == 200
+          true
+        end
+
+        check "creates the heroku-nav-data cookie" do
+          cookie = agent.cookie_jar.cookies(URI.parse(@sso.full_url)).detect { |c| c.name == 'heroku-nav-data' }
+          error("could not find cookie heroku-nav-data") unless cookie
+          error("expected #{@sso.sample_nav_data}, got #{cookie.value}") unless cookie.value == @sso.sample_nav_data
+          true
+        end
+
+        check "displays the heroku layout" do
+          error("could not find Heroku layout") if page_logged_in.search('div#heroku-header').empty?
+          true
+        end
+      end
+    end
+
+
+    ##
+    # On Testing:
+    #  I've opted to not write tests for this
+    #  due to the simple nature it's currently in.
+    #  If this becomes more complex in even the
+    #  least amount, find me (blake) and I'll
+    #  help get tests in.
+    class AllCheck < Check
+
+      def call!
+        args = data[:args]
+        run ProvisionCheck, data
+
+        response = data[:provision_response]
+        data.merge!(:id => response["id"])
+        config = response["config"] || Hash.new
+
+        if args
+          screen.message "\n\n"
+          screen.message "Starting #{args.first}..."
+          screen.message "\n\n"
+
+          run_in_env(config) { system(*args) }
+          error("run exited abnormally, expected 0, got #{$?.to_i}") unless $?.to_i == 0
+
+          screen.message "\n"
+          screen.message "End of #{args.first}\n"
+        end
+
+        run DeprovisionCheck, data
+      end
+
+      def run_in_env(env)
+        env.each {|key, value| ENV[key] = value }
+        yield
+        env.keys.each {|key| ENV.delete(key) }
+      end
+
+    end
+
+  end
+end