samorau 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+addon-manifest.json

data/NOTES

@@ -0,0 +1,28 @@
+samorau
+  1. to wait for a chance
+  2. to serve by ones side
+
+check man
+  - invalid
+  - valid
+  - invalid price (show error)
+  - multiple plans
+
+check create
+  - server not running
+  - no config (no output)
+  - config
+
+check all
+  - uses id from response
+
+run
+  - ENV["FOO"]
+
+arch
+
+  - chain of responsiblity
+  - commands pass by data
+
+show contest
+show turn

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "samorau"
+    gemspec.summary = ""
+    gemspec.description = ""
+    gemspec.email = "pedro@heroku.com"
+    gemspec.homepage = "http://heroku.com"
+    gemspec.authors = ["Blake Mizerany", "Pedro Belo", "Adam Wiggins"]
+
+    gemspec.add_development_dependency(%q<turn>, [">= 0"])
+    gemspec.add_development_dependency(%q<contest>, [">= 0"])
+    gemspec.add_dependency(%q<sinatra>, ["~> 0.9"])
+    gemspec.add_dependency(%q<rest-client>, ["~> 1.2.0"])
+    gemspec.add_dependency(%q<yajl-ruby>, ["~> 0.6"])
+    gemspec.add_dependency(%q<term-ansicolor>, ["~> 1.0"])
+
+    gemspec.version = '0.1.0'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/TODO

@@ -0,0 +1,8 @@
+
+[ ] heroku-addon test -n delete  # run specific test [create | delete | sharing]
+[ ] heroku-addon test  # run full test suite
+[ ] heroku-addon repl command # runs create, set ENVs, then delete on exit
+[ ] heroku-addon push  # push manifest to heroku
+
+[X] heroku-addon check # check correctnes of JSON
+[X] heroku-addon init  # generate skeleton manifest

data/a-server.rb

@@ -0,0 +1,21 @@
+require 'sinatra'
+require 'yajl'
+require 'restclient'
+
+post "/heroku/resources" do
+  request.body.rewind
+  input = Yajl::Parser.parse(request.body.read)
+  resp = { :id => 123, :config => { "FOO" => "bar" } }
+  #resp = { :id => 456 }
+  json = Yajl::Encoder.encode(resp)
+  fork do
+    sleep 2
+    p input
+    RestClient.put(input["callback_url"], json)
+  end
+  "{}"
+end
+
+delete "/heroku/resources/:id" do
+  "ok"
+end

data/bin/samorau

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+
+require 'term/ansicolor'
+require 'heroku/samorau'
+
+fn="addon-manifest.json"
+async=false
+env="test"
+
+ARGV.options do |o|
+  o.on("-f file", "--file") {|filename| fn = filename }
+  o.on("-h", "--help") { command = "help" }
+  o.on("--async") { async = true }
+  o.on("--production") { env = "production" }
+  o.parse!
+end
+
+command = ARGV.shift
+
+$stdout.sync = true
+
+class Screen
+  include Term::ANSIColor
+
+  def test(msg)
+    $stdout.puts
+    $stdout.puts
+    $stdout.print "Testing #{msg}"
+  end
+
+  def check(msg)
+    $stdout.puts
+    $stdout.print "  Check #{msg}"
+  end
+
+  def error(msg)
+    $stdout.print "\n", magenta("    ! #{msg}")
+  end
+
+  def result(status)
+    msg = status ? bold("[PASS]") : red(bold("[FAIL]"))
+    $stdout.print " #{msg}"
+  end
+
+  def message(msg)
+    $stdout.puts msg
+  end
+
+  def finish
+    $stdout.puts
+    $stdout.puts
+    $stdout.puts "done."
+  end
+
+end
+
+def resolve_manifest(fn)
+  if File.exists?(fn)
+    File.read(fn)
+  else
+    abort("fatal: #{fn} not found")
+  end
+end
+
+def run(klass, fn, extras={})
+  screen = Screen.new
+  data = Yajl::Parser.parse(resolve_manifest(fn))
+  check = klass.new(data.merge(extras), screen)
+  check.call
+  screen.finish
+end
+
+include Heroku::Samorau
+
+case command
+when "init"
+  Manifest.init(fn)
+  Screen.new.message "Initialized new addon manifest in #{fn}"
+when "test"
+  case check = ARGV.shift
+  when "manifest"
+    run ManifestCheck, fn
+  when "provision"
+    run ManifestCheck, fn
+    run CreateCheck, fn, :async => async, :env => env
+  when "deprovision"
+    id = ARGV.shift || abort("! no id specified; see usage")
+    run ManifestCheck, fn
+    run DeleteCheck, fn, :id => id, :async => async, :env => env
+  else
+    abort "! Unknown test '#{check}'; see usage"
+  end
+when "run"
+  abort "! missing command to run; see usage" if ARGV.empty?
+  run ManifestCheck, fn
+  run AllCheck, fn, :args => ARGV, :async => async, :env => env
+else
+  abort DATA.read
+end
+
+__END__
+Usage: samorau [OPTIONS] command
+       samorau init
+       samorau test <type> [arg1 arg2 ...]
+       samorau run <command> [arg1 arg1 ...]
+
+OPTIONS
+
+  -f, --filename path-to-file
+    Sets the manifest file to operate on, default is addon-manifest.json.
+
+  -h, --help
+    Show this message
+
+  --async
+    Check provision call with async response.
+
+COMMANDS
+
+  init            Creates a skeleton manifest
+
+  test <type>     Simulate call from Heroku (provision or deprovision)
+
+  run <command>   Provisions a resource and runs command in returned ENV
+
+TEST TYPES
+
+  provision
+    Simulate a provision call from Heroku.
+
+  deprovision <id>
+    Simulate a deprovision call from Heroku.
+
+  manifest
+    Confirm that the manifest is valid.  Automatically runs before all tests.
+

data/lib/heroku/samorau.rb

@@ -0,0 +1,465 @@
+require 'yajl'
+require 'restclient'
+require 'socket'
+require 'timeout'
+
+module Heroku
+
+  module Samorau
+
+    module Manifest
+
+      def self.init(filename)
+        json = Yajl::Encoder.encode(skeleton, :pretty => true)
+        open(filename, 'w') {|f| f << json }
+      end
+
+      def self.skeleton
+        {
+          "name" => "myaddon",
+
+          "api" => {
+            "username" => "heroku",
+            "password" => generate_password,
+            "test" => "http://localhost:4567/",
+            "production" => "https://yourapp.com/",
+            "config_vars" => ["MYADDON_URL"]
+          },
+
+          "plans" => [
+            {
+              "name" => "Basic",
+              "price" => "0",
+              "price_unit" => "month"
+            }
+          ]
+        }
+      end
+
+      def self.generate_password
+        Array.new(8) { rand(256) }.pack('C*').unpack('H*').first
+      end
+
+    end
+
+
+    class NilScreen
+
+      def test(msg)
+      end
+
+      def check(msg)
+      end
+
+      def error(msg)
+      end
+
+      def result(status)
+      end
+
+    end
+
+
+    class Check
+      attr_accessor :screen, :data
+
+      class CheckError < StandardError ; end
+
+      def initialize(data, screen=NilScreen.new)
+        @data = data
+        @screen = screen
+      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
+
+    end
+
+
+    class ManifestCheck < Check
+
+      ValidPriceUnits = %w[month dyno_hour]
+
+      def call!
+        test "manifest name key"
+        check "if exists" do
+          data.has_key?("name")
+        end
+        check "is a string" do
+          data["name"].is_a?(String)
+        end
+        check "is not blank" do
+          !data["name"].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 username" do
+          data["api"].has_key?("username") && data["api"]["username"] != ""
+        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
+        check "production url uses SSL" do
+          data["api"]["production"] =~ /^https:/
+        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
+
+        test "plans"
+        check "key must exist" do
+          data.has_key?("plans")
+        end
+        check "is an array" do
+          data["plans"].is_a?(Array)
+        end
+        check "contains at least one plan" do
+          !data["plans"].empty?
+        end
+        check "all plans are a hash" do
+          data["plans"].all? {|plan| plan.is_a?(Hash) }
+        end
+        check "all plans have a name" do
+          data["plans"].all? {|plan| plan.has_key?("name") }
+        end
+        check "all plans have a unique name" do
+          names = data["plans"].map {|plan| plan["name"] }
+          names.size == names.uniq.size
+        end
+
+        data["plans"].each do |plan|
+          check "#{plan["name"]} has a valid price" do
+            if plan["price"] !~ /^\d+$/
+              error "expected an integer"
+            else
+              true
+            end
+          end
+
+          check "#{plan["name"]} has a valid price_unit" do
+            if ValidPriceUnits.include?(plan["price_unit"])
+              true
+            else
+              error "expected #{ValidPriceUnits.join(" or ")} but got #{plan["price_unit"].inspect}"
+            end
+          end
+        end
+      end
+
+    end
+
+
+    class CreateResponseCheck < Check
+
+      def call!
+        response = data[:create_response]
+        test "response"
+        check "contains an id" do
+          response.has_key?("id")
+        end
+
+        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 config values are strings" do
+            response["config"].each do |k, v|
+              if v.is_a?(String)
+                true
+              else
+                error "#{v.inspect} is not a string"
+              end
+            end
+          end
+        end
+      end
+
+    end
+
+
+    module HTTP
+
+      def post(credentials, path, payload=nil)
+        request(:post, credentials, path, payload)
+      end
+
+      def delete(credentials, path, payload=nil)
+        request(:delete, credentials, path, payload)
+      end
+
+      def request(meth, credentials, path, payload=nil)
+        code = nil
+        body = nil
+
+        begin
+          args = [
+            (Yajl::Encoder.encode(payload) if payload),
+            {
+              :accept => "application/json",
+              :content_type => "application/json"
+            }
+          ].compact
+
+          user, pass = credentials
+          body = RestClient::Resource.new(url, user, pass)[path].send(
+            meth,
+            *args
+          )
+
+          code = 200
+        rescue RestClient::ExceptionWithResponse => boom
+          code = boom.http_code
+          body = boom.http_body
+        rescue Errno::ECONNREFUSED
+          code = -1
+          body = nil
+        end
+
+        [code, body]
+      end
+
+    end
+
+    class ApiCheck < Check
+      def url
+        env = data[:env] || 'test'
+        data["api"][env].chomp("/")
+      end
+
+      def credentials
+         %w( username password ).map { |attr| data["api"][attr] }
+      end
+    end
+
+    class CreateCheck < ApiCheck
+      include HTTP
+
+      READLEN = 1024 * 10
+      APPID = "app123@heroku.com"
+
+      def call!
+        json = nil
+        response = nil
+
+        code = nil
+        json = nil
+        path = "/heroku/resources"
+        callback = "http://localhost:7779/callback/999"
+        reader, writer = nil
+
+        payload = {
+          :id => APPID,
+          :plan => "Basic",
+          :callback_url => callback
+        }
+
+        if data[:async]
+          reader, writer = IO.pipe
+        end
+
+        test "POST /heroku/resources"
+        check "response" do
+          if data[:async]
+            child = fork do
+              Timeout.timeout(10) 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
+            end
+            sleep(1)
+          end
+
+          code, json = post(credentials, 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, path, payload)
+          error("expected 401, got #{code}") if code != 401
+          true
+        end
+
+        data[:create_response] = response
+
+        run CreateResponseCheck, data
+      end
+
+    ensure
+      reader.close rescue nil
+      writer.close rescue nil
+    end
+
+
+    class DeleteCheck < ApiCheck
+      include HTTP
+
+      def call!
+        id = data[:id]
+        raise ArgumentError, "No id specified" if id.nil?
+
+        path = "/heroku/resources/#{id}"
+
+        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
+
+
+    ##
+    # 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 CreateCheck, data
+
+        response = data[:create_response]
+        id = response["id"]
+        config = response["config"] || Hash.new
+
+        if args
+          screen.message "\n\n"
+          screen.message "Starting #{args.first}..."
+          screen.message ""
+
+          run_in_env(config) { system(*args) }
+
+          screen.message ""
+          screen.message "End of #{args.first}"
+        end
+
+        run DeleteCheck, data.merge(:id => id)
+      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

data/samorau.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{samorau}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Blake Mizerany", "Pedro Belo", "Adam Wiggins"]
+  s.date = %q{2010-02-11}
+  s.default_executable = %q{samorau}
+  s.description = %q{}
+  s.email = %q{pedro@heroku.com}
+  s.executables = ["samorau"]
+  s.extra_rdoc_files = [
+    "TODO"
+  ]
+  s.files = [
+    ".gitignore",
+     "NOTES",
+     "Rakefile",
+     "TODO",
+     "a-server.rb",
+     "bin/samorau",
+     "lib/heroku/samorau.rb",
+     "samorau.gemspec",
+     "server.rb",
+     "set-env.sh",
+     "test/create_check_test.rb",
+     "test/create_response_check_test.rb",
+     "test/delete_check.rb",
+     "test/helper.rb",
+     "test/manifest_check_test.rb"
+  ]
+  s.homepage = %q{http://heroku.com}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{}
+  s.test_files = [
+    "test/create_check_test.rb",
+     "test/create_response_check_test.rb",
+     "test/delete_check.rb",
+     "test/helper.rb",
+     "test/manifest_check_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<turn>, [">= 0"])
+      s.add_development_dependency(%q<contest>, [">= 0"])
+      s.add_runtime_dependency(%q<sinatra>, ["~> 0.9"])
+      s.add_runtime_dependency(%q<rest-client>, ["~> 1.2.0"])
+      s.add_runtime_dependency(%q<yajl-ruby>, ["~> 0.6"])
+      s.add_runtime_dependency(%q<term-ansicolor>, ["~> 1.0"])
+    else
+      s.add_dependency(%q<turn>, [">= 0"])
+      s.add_dependency(%q<contest>, [">= 0"])
+      s.add_dependency(%q<sinatra>, ["~> 0.9"])
+      s.add_dependency(%q<rest-client>, ["~> 1.2.0"])
+      s.add_dependency(%q<yajl-ruby>, ["~> 0.6"])
+      s.add_dependency(%q<term-ansicolor>, ["~> 1.0"])
+    end
+  else
+    s.add_dependency(%q<turn>, [">= 0"])
+    s.add_dependency(%q<contest>, [">= 0"])
+    s.add_dependency(%q<sinatra>, ["~> 0.9"])
+    s.add_dependency(%q<rest-client>, ["~> 1.2.0"])
+    s.add_dependency(%q<yajl-ruby>, ["~> 0.6"])
+    s.add_dependency(%q<term-ansicolor>, ["~> 1.0"])
+  end
+end
+

data/server.rb

@@ -0,0 +1,13 @@
+require 'sinatra'
+require 'yajl'
+require 'restclient'
+
+post "/heroku/resources" do
+  resp = { :id => 123, :config => { "FOO" => "bar" } }
+  #resp = { :id => 123 }
+  Yajl::Encoder.encode(resp)
+end
+
+delete "/heroku/resources/:id" do
+  "ok"
+end

data/set-env.sh

@@ -0,0 +1,4 @@
+PATH=$(pwd)/bin:$PATH
+RUBYOPT=rubygems
+RUBYLIB=$(pwd)/lib:$RUBYLIB
+export PATH RUBYOPT RUBYLIB

data/test/create_check_test.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + "/helper"
+require "heroku/samorau"
+
+class CreateCheckTest < Test::Unit::TestCase
+  include Heroku::Samorau
+
+  setup do
+    @data = Manifest.skeleton
+    @responses = [
+      [200, to_json({ :id => 456 })],
+      [401, "Unauthorized"]
+    ]
+  end
+
+  def check ; CreateCheck ; end
+
+  test "valid on 200 for the regular check, and 401 for the auth check" do
+    assert_valid do |check|
+      stub :post, check, @responses
+    end
+  end
+
+  test "invalid JSON" do
+    @responses[0] = [200, "---"]
+    assert_invalid do |check|
+      stub :post, check, @responses
+    end
+  end
+
+  test "status other than 200" do
+    @responses[0] = [500, to_json({ :id => 456 })]
+    assert_invalid do |check|
+      stub :post, check, @responses
+    end
+  end
+
+  test "runs create response check" do
+    @responses[0] = [200, to_json({ :noid => 456 })]
+    assert_invalid do |check|
+      stub :post, check, @responses
+    end
+  end
+
+  test "runs auth check" do
+    @responses[1] = [200, to_json({ :id => 456 })]
+    assert_invalid do |check|
+      stub :post, check, @responses
+    end
+  end
+
+end

data/test/create_response_check_test.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + "/helper"
+require 'heroku/samorau'
+
+class CreateResponseCheckTest < Test::Unit::TestCase
+  include Heroku::Samorau
+
+  def check ; CreateResponseCheck ; end
+
+  setup do
+    @response = { "id" => "123" }
+    @data = Manifest.skeleton.merge(:create_response => @response)
+  end
+
+  test "is valid if no errors" do
+    assert_valid
+  end
+
+  test "has an id" do
+    @response.delete("id")
+    assert_invalid
+  end
+
+  describe "when config is present" do
+
+    test "is a hash" do
+      @response["config"] = ""
+      assert_invalid
+    end
+
+    test "each key is previously set in the manifest" do
+      @response["config"] = { "MYSQL_URL" => "http://..." }
+      assert_invalid
+    end
+
+    test "each value is a string" do
+      @response["config"] = { "MYADDON_URL" => {} }
+      assert_invalid
+    end
+
+    test "is valid otherwise" do
+      @response["config"] = { "MYADDON_URL" => "http://..." }
+      assert_valid
+    end
+  end
+
+end

data/test/delete_check.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + "/helper"
+require "heroku/samorau"
+
+class DeleteCheckTest < Test::Unit::TestCase
+  include Heroku::Samorau
+
+  setup do
+    @data = Manifest.skeleton.merge :id => 123
+    @responses = [
+      [200, ""],
+      [401, ""],
+    ]
+  end
+
+  def check ; DeleteCheck ; end
+
+  test "valid on 200" do
+    assert_valid do |check|
+      stub :delete, check, @responses
+    end
+  end
+
+  test "status other than 200" do
+    @responses[0] = [500, ""]
+    assert_invalid do |check|
+      stub :delete, check, @responses
+    end
+  end
+
+  test "runs auth check" do
+    @responses[1] = [200, ""]
+    assert_invalid do |check|
+      stub :delete, check, @responses
+    end
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,47 @@
+require 'contest'
+
+class Test::Unit::TestCase
+
+  def assert_valid(data=@data, &blk)
+    check = create_check(data, &blk)
+    assert check.call
+  end
+
+  def assert_invalid(data=@data, &blk)
+    check = create_check(data, &blk)
+    assert !check.call
+  end
+
+  def create_check(data, &blk)
+    check = self.check.new(data)
+    blk.call(check) if blk
+    check
+  end
+
+  module Headerize
+    attr_accessor :headers
+  end
+
+  def to_json(data, headers={})
+    body = Yajl::Encoder.encode(data)
+    add_headers(body, headers)
+  end
+
+  def add_headers(o, headers={})
+    o.extend Headerize
+    o.headers = {}
+    o.headers["Content-Type"] ||= "application/json"
+    o.headers.merge!(headers)
+    o
+  end
+
+  def stub(meth, o, returns)
+    o.instance_eval { @returns = Array(returns) }
+    eval <<-EVAL
+    def o.#{meth}(*args)
+      @returns.shift || fail("Nothing else to return from stub'ed method")
+    end
+    EVAL
+  end
+
+end

data/test/manifest_check_test.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__) + "/helper"
+require 'heroku/samorau'
+
+class ManifestCheckTest < Test::Unit::TestCase
+  include Heroku::Samorau
+
+  def check ; ManifestCheck ; end
+
+  setup do
+    @data = Manifest.skeleton
+  end
+
+  test "is valid if no errors" do
+    assert_valid
+  end
+
+  test "has a name" do
+    @data.delete("name")
+    assert_invalid
+  end
+
+  test "api key exists" do
+    @data.delete("api")
+    assert_invalid
+  end
+
+  test "api is a Hash" do
+    @data["api"] = ""
+    assert_invalid
+  end
+
+  test "api has a username" do
+    @data["api"].delete("username")
+    assert_invalid
+  end
+
+  test "api has a password" do
+    @data["api"].delete("password")
+    assert_invalid
+  end
+
+  test "api contains test" do
+    @data["api"].delete("test")
+    assert_invalid
+  end
+
+  test "api contains production" do
+    @data["api"].delete("production")
+    assert_invalid
+  end
+
+  test "api contains production of https" do
+    @data["api"]["production"] = "http://foo.com"
+    assert_invalid
+  end
+
+  test "api contains config_vars array" do
+    @data["api"]["config_vars"] = "test"
+    assert_invalid
+  end
+
+  test "api contains at least one config var" do
+    @data["api"]["config_vars"].clear
+    assert_invalid
+  end
+
+  test "all config vars are in upper case" do
+    @data["api"]["config_vars"] << 'invalid_var'
+    assert_invalid
+  end
+
+  test "plans key must exist" do
+    @data.delete("plans")
+    assert_invalid
+  end
+
+  test "plans key must be an Array" do
+    @data["plans"] = ""
+    assert_invalid
+  end
+
+  test "has at least one plan" do
+    @data["plans"] = []
+    assert_invalid
+  end
+
+  test "all plans are a hash" do
+    @data["plans"][0] = ""
+    assert_invalid
+  end
+
+  test "all plans have a name" do
+    @data["plans"].first.delete("name")
+    assert_invalid
+  end
+
+  test "all plans have a unique name" do
+    @data["plans"] << @data["plans"].first.dup
+    assert_invalid
+  end
+
+  test "plans have a price" do
+    @data["plans"].first.delete("price")
+    assert_invalid
+  end
+
+  test "plans have an integer price" do
+    @data["plans"].first["price"] = "fiddy cent"
+    assert_invalid
+  end
+
+  test "plans have a valid price_unit" do
+    @data["plans"].first["price_unit"] = "first ov da munth"
+    assert_invalid
+  end
+
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: samorau
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Blake Mizerany
+- Pedro Belo
+- Adam Wiggins
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-11 00:00:00 -08:00
+default_executable: samorau
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: turn
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: contest
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.9"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: term-ansicolor
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+description: ""
+email: pedro@heroku.com
+executables: 
+- samorau
+extensions: []
+
+extra_rdoc_files: 
+- TODO
+files: 
+- .gitignore
+- NOTES
+- Rakefile
+- TODO
+- a-server.rb
+- bin/samorau
+- lib/heroku/samorau.rb
+- samorau.gemspec
+- server.rb
+- set-env.sh
+- test/create_check_test.rb
+- test/create_response_check_test.rb
+- test/delete_check.rb
+- test/helper.rb
+- test/manifest_check_test.rb
+has_rdoc: true
+homepage: http://heroku.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: 
+- test/create_check_test.rb
+- test/create_response_check_test.rb
+- test/delete_check.rb
+- test/helper.rb
+- test/manifest_check_test.rb