kensa 1.2.0rc7 → 1.2.0

data/lib/heroku/kensa/version.rb

@@ -1,6 +1,5 @@
 module Heroku
   module Kensa
-    VERSION = "1.2.0rc7"
+    VERSION = '1.2.0'
   end
 end
-

data/test/all_check_test.rb

@@ -0,0 +1,25 @@
+require 'test/helper'
+
+class AllCheckTest < Test::Unit::TestCase
+  include Heroku::Kensa
+
+  setup do
+    @data = Manifest.new(:method => :get).skeleton
+    @data['api']['password'] = 'secret'
+    @data['api']['test'] += "working"
+    @file = File.dirname(__FILE__) + "/resources/runner.rb"
+  end
+
+  def check; AllCheck; end
+
+  test "valid on script exit 0" do
+    @data[:args] = ["ruby #{@file}"]
+    assert_valid
+  end
+
+  test "invalid on script exit non 0" do
+    @data[:args] = ["ruby #{@file} fail"]
+    assert_invalid
+  end
+
+end

data/test/create_test.rb

@@ -1,12 +1,46 @@
-$:.unshift(File.expand_path("../..",__FILE__))
-require 'test/lib/dependencies'
+require 'test/helper'
 
 class CreateTest < Test::Unit::TestCase
-  def kensa(cmd)
-    `./bin/kensa #{cmd}`
+  include Heroku::Kensa
+
+  def setup
+    stub(Git).run
+    any_instance_of Client do |client|
+      stub(client).init
+    end
+    stub(Dir).chdir
+  end
+
+  def test_requires_app_name
+    assert_raise Client::CommandInvalid do
+      kensa "create my_addon"
+    end
+  end
+
+  def test_requires_template
+    assert_raise Client::CommandInvalid do
+      kensa "create --template foo"
+    end
+  end
+
+  def test_assumes_heroku_template
+    kensa "create my_addon --template sinatra"
+    assert_received Git do |git|
+      git.run("git clone git://github.com/heroku/kensa-create-sinatra my_addon")
+    end
+  end
+
+  def test_assumes_github
+    kensa "create my_addon --template heroku/sinatra"
+    assert_received Git do |git|
+      git.run("git clone git://github.com/heroku/sinatra my_addon")
+    end
   end
 
-  def test_create_with_manifest
-    kensa "create"
+  def test_allows_full_url
+    kensa "create my_addon --template git://heroku.com/sinatra.git"
+    assert_received Git do |git|
+      git.run("git clone git://heroku.com/sinatra.git my_addon")
+    end
   end
 end

data/test/deprovision_check_test.rb

@@ -0,0 +1,39 @@
+require 'test/helper'
+
+class DeprovisionCheckTest < Test::Unit::TestCase
+  include Heroku::Kensa
+
+  %w{get post}.each do |method|
+    context "with SSO #{method}" do
+      setup do
+        @data = Manifest.new(:method => method).skeleton.merge :id => 123
+        @responses = [
+          [200, ""],
+          [401, ""],
+        ]
+      end
+
+      def check ; DeprovisionCheck ; end
+
+      test "valid on 200" do
+        assert_valid do |check|
+          kensa_stub :delete, check, @responses
+        end
+      end
+
+      test "status other than 200" do
+        @responses[0] = [500, ""]
+        assert_invalid do |check|
+          kensa_stub :delete, check, @responses
+        end
+      end
+
+      test "runs auth check" do
+        @responses[1] = [200, ""]
+        assert_invalid do |check|
+          kensa_stub :delete, check, @responses
+        end
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -1,21 +1,84 @@
-require 'rubygems'
-require 'bundler/setup'
+require 'heroku/kensa'
+require 'heroku/kensa/client'
+require 'contest'
 require 'timecop'
 require 'rr'
-require 'test/unit'
-require 'lib/heroku/kensa'
-require 'test/resources/provider_server'
+require 'yajl'
 
 class Test::Unit::TestCase
   include RR::Adapters::TestUnit
 
-  def setup
-    Timecop.freeze Time.now.utc
-    Artifice.activate_with(ProviderServer.new(manifest))
+  def kensa(command)
+    Heroku::Kensa::Client.new(command.split, :silent => true).run!
   end
 
-  def teardown
-    Timecop.return
-    Artifice.deactivate
+  def read_json(filename)
+    Yajl::Parser.parse(File.open(filename).read)
+  end
+
+  #this prepends a prefix for the provider server
+  #in test/resources/server.rb
+  def use_provider_endpoint(name, type = 'base')
+    if @data['api']['test'].is_a? Hash 
+      url = @data['api']['test']["#{type}_url"]
+      path = URI.parse(url).path
+      @data['api']['test']["#{type}_url"] = url.sub(path, "/#{name}#{path}")
+    else
+      @data['api']['test'] += "#{name}"
+    end
+  end
+  
+  def trace!
+    @screen = Heroku::Kensa::IOScreen.new(STDOUT)
+  end
+
+  def screen
+    @screen ||= Heroku::Kensa::IOScreen.new(StringIO.new("", 'w+'))
+  end
+
+  # call trace! in your test before the 
+  # assert to see the output
+  def assert_valid(data=@data, &blk)
+    check = create_check(data, &blk)
+    result = check.call
+    assert result, screen.to_s
+  end
+
+  def assert_invalid(data=@data, &blk)
+    check = create_check(data, &blk)
+    result = check.call
+    assert !result, screen.to_s
+  end
+
+  def create_check(data, &blk)
+    check = self.check.new(data, screen)
+    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 kensa_stub(meth, o, returns)
+    o.instance_eval { @returns = Array(returns) }
+    eval <<-EVAL
+    def o.#{meth}(*args)
+      @returns.shift or fail("Nothing else to return from stub'ed method")
+    end
+    EVAL
   end
 end

data/test/init_test.rb

@@ -0,0 +1,54 @@
+require 'test/helper'
+require 'fakefs/safe'
+
+class InitTest < Test::Unit::TestCase
+  def setup
+    FakeFS.activate!
+    @filename = 'addon-manifest.json'
+  end
+
+  def teardown
+    File.unlink(@filename) if @filename && File.exist?(@filename)
+    FakeFS.deactivate!
+  end
+  
+  def test_init_default_so_sso_post
+    kensa "init"
+    manifest = read_json(@filename)
+    %w{test production}.each do |env|
+      %w{base_url sso_url}.each do |url|
+        assert manifest['api'][env][url] =~ /^http/
+      end
+    end
+    assert !File.exist?('.env')
+  end
+
+  def test_init_uses_file_flag
+    @filename = 'foo.json'
+
+    kensa "init -f #{@filename}"
+    assert !File.exist?('./addon-manifest.json')
+    assert !File.exist?('.env')
+    manifest = read_json(@filename)
+  end
+
+  def test_init_uses_sso_flag
+    kensa "init --sso get"
+    manifest = read_json(@filename)
+    %w{test production}.each do |env|
+      assert manifest['api'][env] =~ /^http/
+    end
+    assert !File.exist?('.env')
+  end
+
+  def test_init_with_env_flag
+    kensa "init --foreman"
+    env = File.open(".env").read
+    manifest = read_json(@filename)
+    assert manifest['api']['test']['base_url'] =~ /:5000/
+    assert manifest['api']['test']['sso_url'] =~ /:5000/
+    assert env.include?("SSO_SALT=#{manifest['api']['sso_salt']}\n")
+    assert env.include?("HEROKU_USERNAME=#{manifest['id']}\n")
+    assert env.include?("HEROKU_PASSWORD=#{manifest['api']['password']}")
+  end
+end

data/test/manifest_check_test.rb

@@ -0,0 +1,94 @@
+require 'test/helper'
+
+class ManifestCheckTest < Test::Unit::TestCase
+  include Heroku::Kensa
+
+  def check ; ManifestCheck ; end
+
+  %w{get post}.each do |method|  
+    context "with sso #{method}" do 
+      setup { @data = Manifest.new(:method => method).skeleton }
+
+      test "is valid if no errors" do
+        assert_valid
+      end
+
+      test "has an id" do
+        @data.delete("id")
+        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 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
+        if method == 'get'
+          @data["api"]["production"] = "http://foo.com"
+        else
+          @data["api"]["production"]['base_url'] = "http://foo.com"
+        end
+        assert_invalid
+      end
+
+      if method == 'post'
+        test "sso contains production of https" do
+          @data["api"]["production"]['sso_url'] = "http://foo.com"
+          assert_invalid
+        end
+      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"] << 'MYADDON_invalid_var'
+        assert_invalid
+      end
+
+      test "assert config var prefixes match addon id" do
+        @data["api"]["config_vars"] << 'MONGO_URL'
+        assert_invalid
+      end
+
+      test "replaces dashes for underscores on the config var check" do
+        @data["id"] = "MY-ADDON"
+        @data["api"]["config_vars"] = ["MY_ADDON_URL"]
+        assert_valid
+      end
+
+      test "username is deprecated" do
+        @data["api"]["username"] = "heroku"
+        assert_invalid
+      end
+    end
+  end
+end

data/test/manifest_test.rb

@@ -1,51 +1,55 @@
-$:.unshift(File.expand_path("../..",__FILE__))
 require 'test/helper'
+
 class ManifestTest < Test::Unit::TestCase
+  include Heroku::Kensa
 
-  def test_has_an_id
-    assert manifest["id"], "Manifest needs to specify the ID of the add-on."
-  end
+  context 'GET manifest' do
+    setup { @manifest = Manifest.new(:method => :get) }
 
-  def test_has_a_hash_of_api_settings
-    assert manifest["api"], "Manifest needs to contain a Hash of API settings."
-    assert manifest["api"].is_a?(Hash), "Manifest needs to contain a Hash of API settings."
-  end
+    test 'have sso salt' do
+      assert_not_nil @manifest.skeleton['api']['sso_salt']
+    end
 
-  def test_api_has_a_password
-    assert manifest["api"]["password"], "Manifest must define a password within the API settings."
-  end
+    test 'generates a new sso salt every time' do
+      assert @manifest.skeleton['api']['sso_salt'] != Manifest.new.skeleton['api']['sso_salt']
+    end
 
-  def test_api_contains_test
-    assert manifest["api"]["test"], "Manifest must define a test environment with the API settings."
-  end
+    test 'has an api password' do
+      assert_not_nil @manifest.skeleton['api']['password']
+    end
 
-  def test_api_contains_production
-    assert manifest["api"]["production"], "Manifest must define a production environment with the API settings."
-  end
+    test 'generates a new password every time' do
+      assert @manifest.skeleton['api']['password'] != Manifest.new.skeleton['api']['password']
+    end
 
-  def test_api_contains_production_of_https
-    if manifest["api"]["production"].is_a?(Hash)
-      url = manifest["api"]["production"]["base_url"]
-    else
-      url = manifest["api"]["production"]
+    test 'uses get format' do
+      assert_equal @manifest.skeleton['api']['test'], 'http://localhost:4567/'
+      assert_equal @manifest.skeleton['api']['production'], 'https://yourapp.com/'
     end
-    assert url.match(%r{\Ahttps://}), "Production environment must communicate over HTTPS."
   end
 
-  def test_all_config_vars_are_in_upper_case
-    manifest["api"]["config_vars"].each do |var|
-      assert_equal var.upcase, var, "All config vars must be uppercase, #{var} is not."
+  context "POST manifest" do
+    setup { @manifest = Manifest.new(:method => :post) }
+
+    test 'uses post format for test url' do
+      assert_equal @manifest.skeleton['api']['test']['base_url'], 'http://localhost:4567/heroku/resources'
+      assert_equal @manifest.skeleton['api']['test']['sso_url'],  'http://localhost:4566/sso/login'
     end
-  end
 
-  def test_assert_config_var_prefixes_match_addon_id
-    id = manifest["id"].upcase.gsub("-", "_")
-    manifest["api"]["config_vars"].each do |var|
-      assert var.match(%r{\A#{id}_}), "All config vars must be prefixed with the add-on ID (#{id}), #{var} is not."
+    test 'uses post format for test url' do
+      assert_equal @manifest.skeleton['api']['production']['base_url'], 'https://yourapp.com/heroku/resources'
+      assert_equal @manifest.skeleton['api']['production']['sso_url'], 'https://yourapp.com/sso/login'
     end
   end
 
-  def test_username_is_deprecated
-    assert !manifest["api"]["username"], "Username has been deprecated."
+  context 'manifest without sso' do
+    setup do
+      options = { :sso => false, :filename => 'test.txt' }
+      @manifest = Manifest.new options
+    end
+
+    test 'exclude sso salt' do
+      assert_nil @manifest.skeleton['api']['sso_salt']
+    end
   end
 end