stormforge-ruby 0.5.0

data/lib/stormforge/dsl/test_case/data_source/random_number.rb

@@ -0,0 +1,64 @@
+  class StormForge::Dsl::TestCase::DataSource::RandomNumber
+    class InvalidRange < Exception; end;
+
+    include ActiveModel::Serializers::JSON
+
+    self.include_root_in_json = false
+
+    attr_reader :name, :range
+
+    def initialize(name, options)
+      @name = name
+      @sequence = 0
+
+      @range = ensure_range(options.fetch(:range, nil))
+    end
+
+    def next
+      args = {
+        t: "random_number",
+        n: name,
+        seq: (@sequence += 1)
+      }
+
+      StormForge::Dsl::TestCase::DataSource.build_marker("GENERATOR", args)
+    end
+
+    def count
+      @sequence
+    end
+
+    def serializable_hash(*args)
+      {
+        name: name,
+        type: "random_number",
+        range: [range.begin, range.end]
+      }
+    end
+
+    private
+
+    # TODO this is not so nice, to raise when called from #initialize
+    # This should be changed to validation errors.
+    def ensure_range(range)
+      unless range
+        raise InvalidRange.new("Range of RandomNumber cannot be nil!")
+      end
+
+      if range.instance_of?(Array) && range.size == 2
+        range = range[0]..range[1]
+      end
+
+      if range.instance_of?(Range)
+        unless range.begin.instance_of?(Fixnum) && range.end.instance_of?(Fixnum)
+          raise InvalidRange.new("Range of RandomNumber needs to be range of Fixnums, between 0 and 100000000")
+        end
+        unless range.begin > 0 && range.end <= 100_000_000
+          raise InvalidRange.new("Range of RandomNumber needs to be between 0 and 100000000")
+        end
+      end
+
+      range
+    end
+  end
+

data/lib/stormforge/dsl/test_case/data_source/random_string.rb

@@ -0,0 +1,52 @@
+class StormForge::Dsl::TestCase::DataSource::RandomString
+  include ActiveModel::Serializers::JSON
+
+  self.include_root_in_json = false
+
+  attr_reader :name, :length
+
+  def initialize(name, options)
+    @name = name
+    @sequence = 0
+
+    @length = ensure_length(options.fetch(:length, 1))
+  end
+
+  def next
+    args = {
+      t: "random_string",
+      n: name,
+      seq: (@sequence += 1)
+    }
+
+    StormForge::Dsl::TestCase::DataSource.build_marker("GENERATOR", args)
+  end
+
+  def count
+    @sequence
+  end
+
+  def serializable_hash(*args)
+    {
+      name: name,
+      type: "random_string",
+      length: @length
+    }
+  end
+
+
+  private
+
+  # TODO casting the length to an integer is not ideal.
+  # We should have validations here too, like for other
+  # DSL related objects.
+  def ensure_length(length)
+    length = length.to_i
+
+    return   1 if length < 1
+    return 100 if length > 100
+
+    length
+  end
+end
+

data/lib/stormforge/dsl/test_case/definition.rb

@@ -0,0 +1,128 @@
+class StormForge::Dsl::TestCase::Definition
+  include ActiveModel::Validations
+  include ActiveModel::Serializers::JSON
+  include ::StormForge::Dsl::TestCase::AttributeAccess
+
+  attr_reader :attributes
+
+  self.include_root_in_json = true
+
+  validates_presence_of :title
+  validates_presence_of :version
+
+  validates :targets, :length => {
+    minimum: 1,
+    too_short: "at least one target is required"
+  }
+  validates :arrival_phases, :length => {
+    minimum: 1,
+    too_short: "at least one arrival phase is required"
+  }
+  validates :sessions, :length => {
+    minimum: 1,
+    too_short: "at least one session is required"
+  }
+
+  class SessionProbabilityValidator < ActiveModel::EachValidator
+    def validate_each(record, attr, value)
+      total_probability = value.values.map(&:probability).sum
+
+      record.errors.add attr, "the total probability of all sessions need to be 100%" unless total_probability == 100
+    end
+  end
+
+  validates :sessions, :session_probability => true
+
+
+  def initialize(slug, callable=nil, &block)
+    @slug = slug
+
+    @attributes = {
+      arrival_phases: [],
+      sessions: {},
+      data_sources: nil
+    }
+    instance_eval(&(callable || block))
+  end
+
+  # TODO this feels messy. is this really the only way to serialize complex attributes?
+  def read_attribute_for_serialization(key)
+    case key
+    when :sessions
+      @attributes[:sessions].each_with_object({}) do |(session_name, session), hash|
+        hash[session_name] = session.serializable_hash
+      end
+    when :cloud
+      @attributes[:cloud].serializable_hash
+    when :data_sources
+      @attributes[:data_sources].serializable_hash if @attributes[:data_sources]
+    else
+      super
+    end
+  end
+
+  def as_json(*args)
+    hash = super
+    hash["dsl_version"] = self.dsl_version.to_s
+    hash["slug"] = slug
+    hash
+  end
+
+  def targets(*targets)
+    return @attributes[:targets] if targets.length == 0
+    @attributes[:targets] = targets.flatten
+  end
+
+  ARRIVAL_PHASE_OPTIONS = {
+    warmup:        false,
+
+    duration:      nil,
+    duration_unit: :second,
+
+    rate:          nil,
+    rate_unit:     :second
+  }.freeze
+
+  def arrival_phase(options)
+    @attributes[:arrival_phases] << ARRIVAL_PHASE_OPTIONS.each_with_object({}) do |(option, default), phase_options|
+      phase_options[option] = options.fetch(option, default)
+    end
+  end
+
+  def session(name, probability, callable=nil, &block)
+    @attributes[:sessions][name] = StormForge::Dsl::TestCase::Session.new(name, probability, @attributes[:data_sources], &(callable || block))
+  end
+
+  def available_attributes
+    [
+      :title,
+      :description,
+      :version,
+      :targets,
+      :arrival_phases,
+      :sessions,
+      :cloud,
+      :data_sources
+    ]
+  end
+
+  def cloud(provider, callable=nil, &block)
+    @attributes[:cloud] = StormForge::Dsl::TestCase::Cloud.new(provider, &(callable || block))
+  end
+
+  def data_sources(callable=nil, &block)
+    if (callable || block)
+      @attributes[:data_sources] = StormForge::Dsl::TestCase::DataSource.new(&(callable || block))
+    else
+      @attributes[:data_sources]
+    end
+  end
+
+  def slug
+    @slug.to_s.downcase.gsub(/[^a-z0-9\-_]/, "_").gsub(/_+/, "_")
+  end
+
+  def dsl_version
+    :v1
+  end
+end

data/lib/stormforge/dsl/test_case/session.rb

@@ -0,0 +1,77 @@
+class StormForge::Dsl::TestCase::Session
+  include ActiveModel::Validations
+  include ActiveModel::Serializers::JSON
+  include ::StormForge::Dsl::TestCase::AttributeAccess
+
+  self.include_root_in_json = false
+
+  attr_reader :attributes, :data_sources
+
+  validates :name, presence: true
+  validates :probability, :inclusion => 1..100, :numericality => true
+  validates :steps, :length => {
+    minimum: 1,
+    too_short: "at least one step is required"
+  }
+
+  def initialize(name, probability, data_sources, callable=nil, &block)
+    @attributes = {
+      name: name,
+      probability: probability,
+      steps: []
+    }
+    @data_sources = data_sources
+
+    instance_eval(&(callable || block))
+  end
+
+  def available_attributes
+    [
+      :name,
+      :probability,
+      :description,
+      :steps
+    ]
+  end
+
+  [:head, :get, :post, :delete, :put, :options, :patch].each do |request_method|
+    define_method(request_method) do |path, options={}|
+      request(request_method, path, options)
+    end
+  end
+
+  def wait(seconds)
+    @attributes[:steps] << {
+      action: :wait,
+      duration: seconds
+    }
+  end
+
+  def pick(what)
+    raise "DataSource #{what} not defined!" unless @data_sources.sources[what]
+    @data_sources.sources[what].next
+  end
+
+  def serializable_hash(*args)
+    hash = super
+    hash[:data_sources_usage] = if data_sources.present?
+                                  data_sources.sources.each_with_object({}) do |(name, source), memo|
+                                    memo[name] = source.count
+                                  end
+                                else
+                                  {}
+                                end
+    hash
+  end
+
+  private
+
+  def request(method, path, options={})
+    @attributes[:steps] << {
+      action: :request,
+      method: method.to_sym,
+      path: path,
+      options: options
+    }
+  end
+end

data/lib/stormforge/registry.rb

@@ -0,0 +1,23 @@
+class StormForge::Registry
+  include Enumerable
+  extend Forwardable
+  def_delegator :test_cases, :each
+  def_delegator :test_cases, :each_pair
+  def_delegator :test_cases, :[]
+  def_delegator :test_cases, :[], :get
+
+  def define(slug, callable=nil, &block)
+    test_cases[slug] = StormForge::Dsl::TestCase.define(slug, callable || block)
+  end
+
+  def reset!
+    @test_cases = {}
+  end
+
+
+  private
+
+  def test_cases
+    @test_cases ||= {}
+  end
+end

data/lib/stormforge/version.rb

@@ -0,0 +1,3 @@
+module StormForge
+  VERSION = "0.5.0"
+end

data/lib/thor/generators/init.rb

@@ -0,0 +1,14 @@
+class StormForge::Thor::Init < Thor::Group
+  include Thor::Actions
+
+  argument :path, :default => "."
+
+  def self.source_root
+    File.join(File.dirname(__FILE__), "templates")
+  end
+
+  def stormfile
+    copy_file "Stormfile", File.join(path, "Stormfile")
+  end
+end
+

data/lib/thor/generators/templates/Stormfile

@@ -0,0 +1,15 @@
+# uncomment this line, to load all test cases in 'test_cases/*'
+# Dir[File.join(File.dirname(__FILE__), "test_cases/*.rb")].each { |test_case| load test_case }
+
+StormForge.define_case :getting_started do
+  title "My first test case"
+  version "0.1"
+  description "Simple and short test to examine test run process."
+  targets "stage.example.com"
+
+  arrival_phase duration: 5.minutes, rate: 1.per_second
+
+  session "hit start page", 100.percent do
+    get "/"
+  end
+end

data/lib/thor/main.rb

@@ -0,0 +1,79 @@
+require "io/console"
+
+class StormForge::Thor::Main < StormForge::Thor::Base
+  class_option :authfile, type: :string, desc: "StormForger authentication file", default: "~/.stormforger"
+  class_option :stormfile, type: :string, desc: "Stormfile location", default: "./Stormfile"
+  class_option :development, type: :boolean, desc: "run in development mode"
+  class_option :skip_ssl_verify, type: :boolean, desc: "skip SSL verification", default: false
+
+  register StormForge::Thor::Init, "init", "init [PATH]", "Initialize new Stormfile"
+
+  desc "version", "Display version information"
+  def version
+    say "stormforge-ruby version #{StormForge::VERSION}"
+  end
+
+  desc "auth", "Aquire an API token"
+  method_option :email, type: :string, desc: 'Your email'
+  method_option :password, type: :string, desc: 'Your password'
+  def auth
+    error "WARNING! Disabling SSL certificate verification is not recommended. Proceed with caution!" if options[:skip_ssl_verify]
+    email, password = options[:email], options[:password]
+
+    email = ask("Please enter your email:") unless email
+    raise Thor::Error, "You must enter a value for that field." if email.empty?
+
+    # TODO: replace with ask("...", :echo => false) if thor gets a new release
+    print "Please enter your password: "
+    password = STDIN.noecho(&:gets).chomp unless password
+    print "\n"
+
+    raise Thor::Error, "You must enter a value for that field." if password.empty?
+
+    say "Attempting to aquire API token..."
+
+    token = StormForge::Client.new(dev_mode: options[:development], skip_ssl_verify: options[:skip_ssl_verify]).aquire_api_token(email, password)
+    raise Thor::Error, "Authentication error!" unless token
+
+    say "Your API authentication is: #{token}", :yellow
+    unless options[:authfile] == "-"
+      say "Writing/Updating credentials to #{authfile}"
+      File.open(authfile, "w+") do |file|
+        file.puts({ email: email, authentication_token: token, created_at: Time.now }.to_json)
+      end
+      File.chmod(0600, authfile)
+    end
+  rescue Faraday::Error::ConnectionFailed => e
+    p e.message
+    raise Thor::Error, "StormForger API not available :-/ (connection failed)"
+  rescue Faraday::Error::ClientError => e
+    if e.response[:status] == 401
+      handle_authentication_error(e)
+    else
+      raise e
+    end
+  end
+
+  desc "ping", "Ping StormForger API"
+  def ping
+    result = client.ping
+    say "pong" if result.status < 399
+  end
+
+  desc "curl", "print curl command template with authentication"
+  def curl
+    say "curl --user '#{authentication["email"]}:#{authentication["authentication_token"]}' -X GET #{client.url_base}"
+  end
+
+  desc "httpie", "print HTTPie command template with authentication"
+  def httpie
+    say "http --auth '#{authentication["email"]}:#{authentication["authentication_token"]}' GET #{client.url_base}"
+  end
+
+  desc "testrun SUBCOMMAND ...ARGS", "Manage test runs"
+  subcommand "testrun", StormForge::Thor::Testrun
+
+  desc "testcase SUBCOMMAND ...ARGS", "Manage test cases"
+  subcommand "testcase", StormForge::Thor::Testcase
+end
+