xplenty-kensa 1.4.5

data/lib/xplenty/kensa/sso.rb

@@ -0,0 +1,133 @@
+require 'restclient'
+require 'uri'
+
+module Xplenty
+  module Kensa
+    class Sso
+      attr_accessor :id, :url, :proxy_port, :timestamp, :token
+
+      def initialize(data)
+        @id   = data[:id]
+        @salt = data['api']['sso_salt']
+
+        env   = data.fetch :env, 'test'
+        if @url = data['api'][env]['sso_url']
+          @use_post   = true
+          @proxy_port = find_available_port
+        else
+          @url  = data["api"][env].chomp('/')
+        end 
+        @timestamp  = Time.now.to_i
+        @token      = make_token(@timestamp)
+      end
+
+      def path
+        if self.POST? 
+          URI.parse(url).path
+        else
+          "/xplenty/resources/#{id}"
+        end
+      end
+
+      def POST?
+        @use_post
+      end
+
+      def sso_url
+        if self.POST?
+          "http://localhost:#{@proxy_port}/"
+        else
+          full_url
+        end
+      end
+
+      def full_url
+        [ url, path, querystring ].join
+      end
+      alias get_url full_url
+
+      def post_url
+        url
+      end
+
+      def timestamp=(other)
+        @timestamp = other
+        @token = make_token(@timestamp)
+      end 
+
+      def make_token(t)
+        Digest::SHA1.hexdigest([@id, @salt, t].join(':'))
+      end
+
+      def querystring
+        return '' unless @salt
+        '?' + query_data 
+      end
+
+      def query_data
+        query_params.map{|p| p.join('=')}.join('&')
+      end
+
+      def query_params
+        { 'token'     => @token,  
+          'timestamp' => @timestamp.to_s,
+          'nav-data'  => sample_nav_data,
+          'email'     => 'username@example.com',
+          'app'       => 'myapp'
+        }.tap do |params|
+          params.merge!('id' => @id) if self.POST?
+        end
+      end
+
+      def sample_nav_data
+        json = OkJson.encode({
+          :addon => 'Your Addon',
+          :appname => 'myapp',
+          :addons => [
+            { :slug => 'cron', :name => 'Cron' },
+            { :slug => 'custom_domains+wildcard', :name => 'Custom Domains + Wildcard' },
+            { :slug => 'youraddon', :name => 'Your Addon', :current => true },
+          ]
+        })
+        base64_url_variant(json)
+      end
+
+      def base64_url_variant(text)
+        base64 = [text].pack('m').gsub('=', '').gsub("\n", '')
+        base64.tr('+/','-_')
+      end
+
+      def message
+        if self.POST?
+          "POSTing #{query_data} to #{post_url} via proxy on port #{@proxy_port}"
+        else
+          "Opening #{full_url}"
+        end
+      end
+
+      def start
+        run_proxy
+        self
+      end
+
+      def find_available_port
+        server = TCPServer.new('127.0.0.1', 0)
+        server.addr[1]
+      ensure
+        server.close if server
+      end
+
+      def run_proxy
+        return unless self.POST?
+        server = PostProxy.new self
+        @proxy = server
+
+        trap("INT") { server.stop }
+        pid = fork do
+          server.start 
+        end
+        at_exit { server.stop; Process.waitpid pid }
+      end
+    end
+  end
+end

data/lib/xplenty/kensa/version.rb

@@ -0,0 +1,5 @@
+module Xplenty
+  module Kensa
+    VERSION = '1.4.5'
+  end
+end

data/lib/xplenty/kensa.rb

@@ -0,0 +1,10 @@
+require 'xplenty/kensa/version'
+require 'xplenty/kensa/http'
+require 'xplenty/kensa/manifest'
+require 'xplenty/kensa/check'
+require 'xplenty/kensa/sso'
+require 'xplenty/kensa/post_proxy'
+require 'xplenty/kensa/screen'
+require 'xplenty/kensa/git'
+require 'xplenty/kensa/okjson'
+require 'xplenty/kensa/okjson-support'

data/test/all_check_test.rb

@@ -0,0 +1,33 @@
+require 'test/helper'
+
+class AllCheckTest < Test::Unit::TestCase
+  include Xplenty::Kensa
+  include ProviderMock
+  include FsMock
+
+  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
+
+  test "all runs" do
+    assert_nothing_raised do
+      kensa "init"
+      kensa "test all"
+    end
+  end
+end

data/test/create_test.rb

@@ -0,0 +1,46 @@
+require 'test/helper'
+
+class CreateTest < Test::Unit::TestCase
+  include Xplenty::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_xplenty_template
+    kensa "create my_addon --template sinatra"
+    assert_received Git do |git|
+      git.run("git clone git://github.com/xplenty/kensa-create-sinatra my_addon")
+    end
+  end
+
+  def test_assumes_github
+    kensa "create my_addon --template xplenty/sinatra"
+    assert_received Git do |git|
+      git.run("git clone git://github.com/xplenty/sinatra my_addon")
+    end
+  end
+
+  def test_allows_full_url
+    kensa "create my_addon --template git://xplenty.com/sinatra.git"
+    assert_received Git do |git|
+      git.run("git clone git://xplenty.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 Xplenty::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

@@ -0,0 +1,115 @@
+require 'xplenty/kensa'
+require 'xplenty/kensa/client'
+require 'contest'
+require 'coveralls'
+require 'timecop'
+require 'rr'
+require 'artifice'
+require 'test/resources/server'
+require 'fakefs/safe'
+
+Coveralls.wear!
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+
+  module ProviderMock
+    def setup
+      Artifice.activate_with(ProviderServer)
+      super
+    end
+
+    def teardown
+      Artifice.deactivate
+      super
+    end
+  end
+
+  module FsMock
+    def setup
+      FakeFS.activate!
+      @filename = 'addon-manifest.json'
+      super
+    end
+
+    def teardown
+      File.unlink(@filename) if @filename && File.exist?(@filename)
+      FakeFS.deactivate!
+      super
+    end
+  end
+
+  def kensa(command)
+    Xplenty::Kensa::Client.new(command.split, :silent => true, :test => true).run!
+  end
+
+  def read_json(filename)
+    OkJson.decode(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 = Xplenty::Kensa::IOScreen.new(STDOUT)
+  end
+
+  def screen
+    @screen ||= Xplenty::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 = OkJson.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,71 @@
+require 'test/helper'
+
+class InitTest < Test::Unit::TestCase
+  include FsMock
+
+  def test_init_doesnt_overwite_addon_manifest
+    File.open(@filename, 'w') { |f| f << '{}' }
+    any_instance_of(Xplenty::Kensa::Client) do |client|
+      stub(client).gets { 'n' }
+      stub(client).print
+      stub(client).puts
+    end
+
+    assert_raises SystemExit do
+      kensa "init"
+    end
+  end
+  
+  def test_init_defaults_to_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 assert_foreman_env(env, manifest)
+    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
+
+  def test_init_with_foreman_flag_and_get
+    kensa "init --foreman --sso get"
+    env = File.open(".env").read
+    manifest = read_json(@filename)
+    assert manifest['api']['test'] =~ /:5000/
+    assert manifest['api']['test'] =~ /:5000/
+    assert_foreman_env env, manifest
+  end
+
+  def test_init_with_foreman_flag_and_post
+    kensa "init --foreman --sso post"
+    env = File.open(".env").read
+    manifest = read_json(@filename)
+    assert manifest['api']['test']['base_url'] =~ /:5000/
+    assert manifest['api']['test']['sso_url'] =~ /:5000/
+    assert_foreman_env env, manifest
+  end
+end

data/test/manifest_check_test.rb

@@ -0,0 +1,123 @@
+require 'test/helper'
+
+class ManifestCheckTest < Test::Unit::TestCase
+  include Xplenty::Kensa
+
+  def check ; ManifestCheck ; end
+
+  test "doesn't barf on OkJson errors" do
+    File.open("addon-manifest.json", 'w') { |f| f << "{,a" }
+    assert_raises Client::CommandInvalid, "addon-manifest.json includes invalid JSON" do
+      kensa "test provision"
+    end
+  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 list of regions" do
+        @data["api"].delete("regions")
+        assert_invalid
+      end
+
+      test "api has a list of regions including US" do
+        @data["api"]["regions"] = ["eu"]
+        assert_invalid
+      end
+
+      test "api only allows valid region names" do
+        @data["api"]["regions"] = ["us", "ap"]
+        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 does not require config_vars" do
+        @data["api"].delete "config_vars"
+        assert_valid
+      end
+
+      context "with config vars" do
+        test "api contains config_vars array" do
+          @data["api"]["config_vars"] = "test"
+          assert_invalid
+        end
+
+        test "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
+      end
+
+      test "username is deprecated" do
+        @data["api"]["username"] = "xplenty"
+        assert_invalid
+      end
+    end
+  end
+end

data/test/manifest_test.rb

@@ -0,0 +1,63 @@
+require 'test/helper'
+
+class ManifestTest < Test::Unit::TestCase
+  include Xplenty::Kensa
+
+  context 'GET manifest' do
+    setup { @manifest = Manifest.new(:method => :get) }
+
+    test 'have sso salt' do
+      assert_not_nil @manifest.skeleton['api']['sso_salt']
+    end
+
+    test 'generates a new sso salt every time' do
+      assert @manifest.skeleton['api']['sso_salt'] != Manifest.new.skeleton['api']['sso_salt']
+    end
+
+    test 'has an api password' do
+      assert_not_nil @manifest.skeleton['api']['password']
+    end
+
+    test 'generates a new password every time' do
+      assert @manifest.skeleton['api']['password'] != Manifest.new.skeleton['api']['password']
+    end
+
+    test 'uses get format' do
+      assert_equal @manifest.skeleton['api']['test'], 'http://localhost:4567/'
+      assert_equal @manifest.skeleton['api']['production'], 'https://yourapp.com/'
+    end
+
+    test 'specifies the US region by default' do
+      assert_equal @manifest.skeleton['api']['regions'], ['us']
+    end
+  end
+
+  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/xplenty/resources'
+      assert_equal @manifest.skeleton['api']['test']['sso_url'],  'http://localhost:4566/sso/login'
+    end
+
+    test 'uses post format for test url' do
+      assert_equal @manifest.skeleton['api']['production']['base_url'], 'https://yourapp.com/xplenty/resources'
+      assert_equal @manifest.skeleton['api']['production']['sso_url'], 'https://yourapp.com/sso/login'
+    end
+
+    test 'specifies the US region by default' do
+      assert_equal @manifest.skeleton['api']['regions'], ['us']
+    end
+  end
+
+  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