rhc 1.14.7 → 1.15.6

data/features/lib/rhc_helper/loggable.rb

@@ -1,37 +0,0 @@
-require 'logger'
-
-module RHCHelper
-  module Loggable
-    def logger
-      Loggable.logger
-    end
-
-    def perf_logger
-      Loggable.perf_logger
-    end
-
-    def self.logger
-      @logger ||= Logger.new($stdout)
-    end
-
-    def self.logger=(logger)
-      @logger = logger
-      original_formatter = Logger::Formatter.new
-      @logger.formatter = proc { |severity, datetime, progname, msg|
-        # Filter out any passwords
-        #filter_msg = msg.gsub(PASSWORD_REGEX, " -p ***** ") 
-
-        # Format with the original formatter
-        original_formatter.call(severity, datetime, progname, msg)
-      }
-    end
-
-    def self.perf_logger
-      @perf_logger ||= Logger.new($stdout)
-    end
-
-    def self.perf_logger=(logger)
-      @perf_logger = logger
-    end
-  end
-end

data/features/lib/rhc_helper/persistable.rb

@@ -1,51 +0,0 @@
-require 'active_support/json'
-require 'active_support/core_ext/object/to_json'
-
-module RHCHelper
-  module Persistable
-    include ActiveSupport::JSON
-    include Loggable
-
-    def find_on_fs(options = {})
-      # Find all apps
-      apps = Dir.glob("#{RHCHelper::TEMP_DIR}/*.json").collect {|f| App.from_file(f)}
-
-      if options.empty?
-        apps.first
-      else
-        apps.find do |app|
-          # Loop through all options and then run AND on all of the results
-          options.map{|name,expected| app.send(name) == expected }.inject(&:&)
-        end
-      end
-    end
-
-    def from_file(filename)
-      App.from_json(ActiveSupport::JSON.decode(File.open(filename, "r") {|f| f.readlines}[0]))
-    end
-
-    def from_json(json)
-      app = App.new(json['type'], json['name'], json['scalable'])
-      app.embed = json['embed']
-      app.mysql_user = json['mysql_user']
-      app.mysql_password = json['mysql_password']
-      app.mysql_hostname = json['mysql_hostname']
-      app.uid = json['uid']
-      # Strip off any version info for the type
-      app.type = app.type.split('-').first
-
-      app
-    end
-  end
-
-  module Persistify
-    include ActiveSupport::JSON
-
-    attr_accessor :file
-
-    def persist
-      json = self.to_json(:except => [:logger, :perf_logger])
-      File.open(@file, "w") {|f| f.puts json}
-    end
-  end
-end

data/features/lib/rhc_helper/runnable.rb

@@ -1,55 +0,0 @@
-require 'open4'
-require 'timeout'
-
-module RHCHelper
-  module Runnable
-    include Loggable
-
-    class StringTee < StringIO
-      attr_reader :tee
-      def initialize(other)
-        @tee = other
-        super()
-      end
-      def <<(buf)
-        tee << buf
-        super
-      end
-    end
-
-    def iconv_handler
-      @iconv ||= Iconv.new('UTF-8//IGNORE', 'UTF-8')
-    end
-
-    def run(cmd, arg=nil, input=[])
-      logger.info("Running: #{cmd} #{arg}")
-
-      exit_code = -1
-      output = nil
-
-      # Don't let a command run more than 5 minutes
-      Timeout::timeout(240) do
-
-        stdout, stderr = (ENV['VERBOSE'] ? [$stdout, $stderr] : [logger, logger]).map{ |t| StringTee.new(t) }
-        stdin = input.inject(StringIO.new){ |io, s| io.puts s; io }
-        stdin.close_write
-        stdin.rewind
-        status = Open4.spawn(cmd, 'stdout' => stdout, 'stderr' => stderr, 'stdin' => stdin, 'quiet' => true)
-        out, err = [stdout, stderr].map(&:string)
-
-        stdout.close
-        stderr.close
-
-        # Allow a caller to pass in a block to process the output
-        yield status.exitstatus, out, err, arg if block_given?
-        exit_code = status.exitstatus
-      end
-
-      if exit_code != 0
-        logger.error("(#{$$}): Execution failed #{cmd} with exit_code: #{exit_code.to_s}")
-      end
-
-      exit_code
-    end
-  end
-end

data/features/lib/rhc_helper/sshkey.rb

@@ -1,33 +0,0 @@
-require "rhc/rest"
-
-module RHCHelper
-
-  class Sshkey
-    extend Runnable
-    extend Commandify
-
-    class << self
-      attr_accessor :sshkey_output, :exitcode
-    end
-
-    def self.list(*args)
-      rhc_sshkey_list args
-    end
-
-    def self.show(*args)
-      rhc_sshkey_show args
-    end
-
-    def self.add(*args)
-      rhc_sshkey_add args
-    end
-
-    def self.remove(*args)
-      rhc_sshkey_remove args
-    end
-
-    def self.keyfile_path(name)
-      File.expand_path(File.join(File.dirname(__FILE__),'..','..','support',name))
-    end
-  end
-end

data/features/multiple_cartridge.feature

@@ -1,19 +0,0 @@
-@multiple_cartridge @domain_required @clean
-Feature: Multiple Cartridge Tests
-
-  @init
-  Scenario: Supporting Cartridge Added
-    Given an existing or new php application with an embedded mysql cartridge
-    When the phpmyadmin cartridge is added
-    Then the phpmyadmin cartridge should be running
-
-  @not-origin
-  Scenario: Multiple DBs Allowed
-    When the postgresql cartridge is added
-    Then the postgresql cartridge should be running
-
-  Scenario: Cartridge Removed
-    When the phpmyadmin cartridge is removed
-    When the mysql cartridge is removed
-    Then the phpmyadmin cartridge should be removed
-    Then the mysql cartridge should be removed

data/features/scaled_application.feature

@@ -1,48 +0,0 @@
-@scaled_application @domain_required
-Feature: Scaled Application Operations
-
-  @init
-  Scenario: Scaled Application Creation
-    When a scaled php application is created
-    Then the application should be accessible
-    Then the application should be scalable
-
-  # The state in these examples should be able to be broken into before hooks when we update cucumber
-  Scenario Outline: Running Scaled Application Commands
-    Given we have a <state> application
-    When the application is <command>
-    Then <what> should <status>
-
-    # Breaking these examples up so they can flow logically, but also be run individually
-    Examples:
-      | state   | command   | what            | status |
-      | running | restarted | the application | be accessible |
-      | running | snapshot  | the snapshot    | be found |
-      | running | tidied    | it              | succeed |
-      | running | shown     | it              | succeed |
-      | running | stopped   | the application | not be accessible |
-      | stopped | started   | the application | be accessible |
-      # After the app is deleted, it is resolving to the OpenShift server
-      #   I think it's because of US2108
-      #   TODO: This needs to be fixed by "not exist" checking DNS instead of HTTP
-      | running | deleted   | it              | succeed |
-
-  Scenario Outline: Changing Scaling Value
-    When we are updating the <cart> cartridge
-    And the <type> scaling value is set to <value>
-    Then the <type> scaling value should be <value>
-
-    Examples:
-      | cart    | type  | value |
-      | php     | min   |   1   |
-      | php     | max   |   5   |
-      | php     | max   |   -1  |
-
-  Scenario Outline: Invalid Scaling Values
-    When we are updating the <cart> cartridge
-    And the <type> scaling value is set to <value>
-    Then it should fail with code <code>
-
-    Examples:
-      | cart    | type  | value | code |
-      | php     | min   |   a   |  1   |

data/features/sshkey.feature

@@ -1,63 +0,0 @@
-@sshkey @client_tools_required
-Feature: SSH key Management
-As an OpenShift user, I want to manage SSH keys with 'rhc sshkey' commands.
-
-  @sshkey_list @key1
-  Scenario: SSH key is listed
-    When a new SSH key "key1.pub" is added as "key1"
-    And the existing keys are listed
-    Then the output includes the key information
-
-  @sshkey_show @key1
-  Scenario: SSH key is shown individually
-    When the key "key1" is shown
-    Then the output includes the key information for "key1"
-
-  @sshkey_show
-  Scenario: Requested SSH key does not exist
-    When the key "key2" is shown
-    Then the command exits with status code 118
-
-  @sshkey_add
-  Scenario: SSH key is added successfully
-    When a new SSH key "key1.pub" is added as "key1"
-    And the key "key1" is shown
-    Then the output includes the key information for "key1"
-    And the command exits with status code 0
-
-  @sshkey_add
-  Scenario: invalid key name is given
-    When a new SSH key "key1.pub" is added as "blah\\ss"
-    Then the command exits with status code 1
-
-  @sshkey_add
-  Scenario: invalid SSH key is added
-    When a new SSH key "key3.pub" is added as "key3"
-    Then the command exits with status code 128
-
-  @sshkey_add
-  Scenario: a valid private SSH key is added
-    When a new SSH key "key1" is added as "key1"
-    Then the command exits with status code 128
-
-  @sshkey_add @key1
-  Scenario: SSH key with the same name already exists
-    When a new SSH key "key2.pub" is added as "key1"
-    Then the command exits with status code 1
-
-  @sshkey_add
-  Scenario: SSH key with the identical content already exists
-    Given a new SSH key "key1.pub" is added as "key1"
-    And a new SSH key "key1.pub" is added as "key2"
-    Then the command exits with status code 1
-
-  @sshkey_remove @key1
-  Scenario: SSH key is deleted successfully
-    When the key "key1" is removed
-    And the key "key1" is shown
-    Then the output does not include the key information for "key1"
-
-  @sshkey_remove
-  Scenario: SSH key requested to be deleted does not exist
-    When the key "key1" is removed
-    Then the command exits with status code 118

data/features/step_definitions/application_steps.rb

@@ -1,120 +0,0 @@
-require 'fileutils'
-require 'rhc/config'
-
-include RHCHelper
-
-# This can transform any application cartridge requirements into an array
-Transform /^application with(.*)$/ do |embed_type|
-  case embed_type.strip
-  when /^out an embedded cartridge/
-    []
-  when /^an embedded (.*) cartridge$/
-    [$1]
-  when /^embedded (.*) and (.*) cartridges$/
-    [$1,$2]
-  end
-end
-
-# Use the transformed array so we can reuse this step for all combinations
-Given /^an existing (or new )?(scaled )?(.+) (application with.*)$/ do |create, scaled, type, embeds|
-  options = { :type => type }
-  options[:embed] = embeds.map{ |c| map_cartridge_type(c) } if embeds
-  options[:scalable] = scaled if scaled
-  @app = App.find_on_fs(options)
-
-  @app = nil if @app.nil? or not @app.is_created?
-
-  if create && @app.nil?
-    step "a #{scaled}#{type} application is created"
-    embeds.each do |embed|
-      step "the #{embed} cartridge is added"
-    end
-  end
-
-  @app.should_not be_nil, "No existing %s applications %sfound.  Check the creation scenarios for failures." % [
-    type,
-    embeds ? '' : "w/ [#{embeds.join(',')}]"
-  ]
-end
-
-# Mark this step as pending so we make sure to explicitly require apps without embeds
-Given /^an existing (or new )?(.+) application$/ do |create,type|
-  pending
-end
-
-When /^(\d+) (.+) applications are created$/ do |app_count, type|
-  old_app = @app
-  @apps = app_count.to_i.times.collect do
-    step "a #{type} application is created"
-    @app
-  end
-  @app = old_app
-end
-
-When /^a (scaled )?(.+) application is created(?: with a (.*) gear)?$/ do |scaled, type, gear_profile|  
-  type = map_cartridge_type(type)
-  @app = App.create_unique(type, scaled, gear_profile)
-  @app.rhc_app_create
-end
-
-When /^the application is (\w+)$/ do |command|
-  # Do any pre-check setup we may need
-  case command
-  when 'snapshot'
-    @snapshot = File.join(RHCHelper::TEMP_DIR, "snapshot.tar.gz")
-    @app.snapshot = @snapshot
-  end
-
-  # Set up aliases for any irregular commands
-  aliases = {
-    :stopped => :stop,
-    :shown   => :show,
-    :tidied  => :tidy,
-    :snapshot => :snapshot_save,
-    :deleted => :delete,
-    :visualized => :show_gears,
-  }
-
-  # Use an alias if it exists, or just remove 'ed' (like from started)
-  cmd = aliases[command.to_sym] || command.gsub(/ed$/,'').to_sym
-
-  # Send the specified command to the application
-  @app.send("rhc_app_#{cmd}")
-end
-
-Then /^the snapshot should be found$/ do
-  File.exist?(@snapshot).should be_true
-  (File.size(@snapshot) > 0).should be_true
-end
-
-Then /^the applications should be accessible?$/ do
-  old_app = @app
-  @apps.each do |app|
-    step "the application should be accessible"
-  end
-  @app = old_app
-end
-
-Then /^the application should be accessible$/ do
-  @app.is_accessible?.should be_true
-  @app.is_accessible?({:use_https => true}).should be_true, "Application was not accessible and should be"
-end
-
-Then /^the application should not be accessible$/ do
-  @app.is_inaccessible?.should be_true, "Application was still accessible when it shouldn't be"
-end
-
-Then /^the application should not exist$/ do
-  @app.doesnt_exist?.should be_true, "Application still exists when it shouldn't"
-end
-
-Then /^it should succeed$/ do
-end
-
-Then /^the application should be scalable/ do
-  step "the haproxy cartridge should be running"
-end
-
-Then /^the application should have a (.*) gear$/ do |gear_profile|
-  @app.gear_profile.should match("#{gear_profile}")
-end

data/features/step_definitions/cartridge_steps.rb

@@ -1,95 +0,0 @@
-require 'fileutils'
-require 'rhc/config'
-
-include RHCHelper
-
-When /^the (.+) cartridge is added$/ do |name|
-  name = map_cartridge_type(name)
-  @app.add_cartridge name
-end
-
-When /^the (.+) cartridge is removed$/ do |name|
-  name = map_cartridge_type(name)
-  @app.remove_cartridge name
-end
-
-When /^the (.+) cartridge is (stopped|(?:re)?started)$/ do |name,command|
-  name = map_cartridge_type(name)
-  cmd = case command.to_sym
-        when :stopped
-          'stop'
-        when :started
-          'start'
-        when :restarted
-          'restart'
-        else
-          raise "Unrecognized command type #{status}"
-        end
-  @app.cartridge(name).send(cmd)
-end
-
-Then /^the (.+) cartridge should be (.*)$/ do |name,status|
-  name = map_cartridge_type(name)
-  expected = case status.to_sym
-             when :running
-               "(.+) is running|Uptime:"
-             when :stopped
-               "(.+) stopped"
-             when :removed
-               "There are no cartridges that match '#{name}'"
-             else
-               raise "Unrecognized status type #{status}"
-             end
-  @app.cartridge(name).status.should match(expected)
-end
-
-Then /^adding the (.+) cartridge should fail$/ do |name|
-  name = map_cartridge_type(name)
-  @app.add_cartridge(name).should == 154
-end
-
-When /^we are updating the (.+) cartridge$/ do |cart|
-  cart = map_cartridge_type(cart)
-  @cartridge_name = cart
-end
-
-When /^the (\w+) scaling value is set to (.*)$/ do |minmax,value|
-  @exitcode = @app.cartridge(@cartridge_name).send(:scale,"--#{minmax} #{value}")
-end
-
-When /^we list cartridges$/ do
-  @exitcode, @cartridge_output = Cartridge.list
-end
-
-When /^we (.+) storage for the (.+) cartridge$/ do |storage_action,cartridge|
-  @output = @app.cartridge(@cartridge_name).send(:storage, cartridge, "--#{storage_action}")
-end
-
-Then /^the (\w+) scaling value should be (.*)$/ do |minmax,value|
-  expected = {
-    :min => "minimum",
-    :max => "maximum"
-  }[minmax.to_sym]
-
-  value = (value == "-1" ? "available" : value)
-
-  match_string = [expected,value].join(": ")
-  regex = Regexp.new(/\b#{match_string}/)
-
-  @app.cartridge(@cartridge_name).send(:show).should match(regex)
-end
-
-Then /^the additional cartridge storage amount should be (\w+)$/ do |value|
-  @output.should == value
-end
-
-Then /^it should fail with code (\d+)$/ do |code|
-  @exitcode.should == code.to_i
-end
-
-Then /^the list should contain the cartridge ([^\s]+) with display name$/ do |name|
-  display_name = map_cartridge_name(name)
-  line = @cartridge_output.each_line.find{ |s| s.include?(name) }
-  line.should_not be_nil
-  line.should match(display_name)
-end