stormforge-ruby 0.5.0

data/lib/core_ext/fixnum.rb

@@ -0,0 +1,20 @@
+require "active_support/core_ext/numeric/time"
+
+class Fixnum
+  def percent
+    self
+  end
+
+  def method_missing(method, *args, &block)
+    if unit = method.to_s.scan(/^per_(second|minute|hour)$/).flatten.first
+      self / 1.send(unit.to_sym).to_f
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    method =~ /^per_(second|minute|hour)$/
+  end
+end
+

data/lib/stormforge.rb

@@ -0,0 +1,39 @@
+require "core_ext/fixnum"
+
+require "active_support"
+require "active_support/core_ext"
+class String
+  alias_method :undent, :strip_heredoc
+end
+require "active_model"
+
+module StormForge
+end
+
+require "stormforge/version"
+
+require "stormforge/client"
+require "stormforge/registry"
+
+require "stormforge/dsl"
+require "stormforge/dsl/test_case"
+require "stormforge/dsl/test_case/attribute_access"
+require "stormforge/dsl/test_case/definition"
+require "stormforge/dsl/test_case/data_source"
+require "stormforge/dsl/test_case/data_source/file_fixture"
+require "stormforge/dsl/test_case/data_source/random_number"
+require "stormforge/dsl/test_case/data_source/random_string"
+require "stormforge/dsl/test_case/session"
+require "stormforge/dsl/test_case/cloud"
+
+module StormForge
+  class << self
+    extend Forwardable
+    def_delegator :registry, :define, :define_case
+    def_delegator :registry, :get, :test_case
+
+    def registry
+      @registry ||= StormForge::Registry.new
+    end
+  end
+end

data/lib/stormforge/client.rb

@@ -0,0 +1,227 @@
+require "faraday"
+require "faraday_middleware"
+
+class StormForge::Client
+
+  attr_reader :email, :token, :url_base
+
+  def initialize(options={})
+    @email = options[:user] || options[:email]
+    @token = options[:token]
+
+    @debug = options[:debug]
+    @logger = options.fetch(:logger, logger)
+
+    @skip_ssl_verification = options.fetch(:skip_ssl_verify, false)
+
+    @url_base = if options[:dev_mode]
+                  "http://localhost:3000/api"
+                else
+                  "https://api.stormforger.com"
+                end
+    @url_base = options[:url_base] if options[:url_base]
+  end
+
+  def connection
+    @connection ||= Faraday.new(url: @url_base, ssl: {
+    verify: !@skip_ssl_verification}) do |faraday|
+      faraday.basic_auth(email, token)
+
+      faraday.headers["User-Agent"] = "stormforge-ruby (#{StormForge::VERSION})"
+      faraday.headers["Content-Type"] = "application/json"
+
+      faraday.request :json
+      faraday.request :multipart
+
+      faraday.response :json, :content_type => /\bjson$/
+
+      faraday.use Faraday::Response::Logger, logger
+      faraday.use Faraday::Response::RaiseError
+
+      faraday.adapter Faraday.default_adapter
+    end
+  end
+
+  def test_run_log(test_run_id, since, limit=10, stream=true, &block)
+    include_start = true
+    while (response = fetch_test_run_log(test_run_id, since, limit, include_start)).body["stats"].present? || stream
+      include_start = false
+      since = response.body["last"] || since
+
+      sleep 1 if response.body["stats"].empty?
+
+      response.body["stats"].each do |stats|
+        yield stats
+      end
+
+      break if response.body["end_reached"]
+    end
+  rescue Interrupt
+    STDERR.puts "aborting..."
+  rescue Faraday::Error::ResourceNotFound
+    raise Thor::Error, "Test Run #{test_run_id} not found!"
+  end
+
+  def fetch_test_run_log(test_run_id, since, limit, include_start)
+    connection.get("#{test_run_endpoint(test_run_id)}/log?since=#{since}&limit=#{limit}&include_start=#{include_start}")
+  end
+
+  def ping
+    connection.get("/")
+  end
+
+  def aquire_api_token(email, password)
+    response = connection.get authentication_endpoint, email: email, password: password
+    return unless response.status == 200
+    response.body["authentication_token"]
+  end
+
+  def create_or_update(test_case)
+    handle_fixtures(test_case)
+
+    handle_test_case(test_case)
+  end
+
+  def handle_fixtures(test_case)
+    return unless test_case.data_sources
+
+    test_case.data_sources.file_fixture_sources.map do |fixture_name, fixture|
+      logger.info "Fixture #{fixture_name} checking (#{fixture.md5_hash})"
+      next if fixture_exists? fixture.md5_hash
+      logger.info "Fixture #{fixture_name} uploading"
+
+      fixture_upload(fixture)
+    end
+  end
+
+  def handle_test_case(test_case)
+    if existing_test_case = fetch_test_case(test_case.slug)
+      test_case_id = existing_test_case["test_cases"][0]["id"]
+    end
+
+    payload = {
+      test_case: {
+        json_definition: test_case.as_json(root: false),
+        dsl_version: test_case.dsl_version || :v1,
+        slug: test_case.slug,
+        title: test_case.title
+      }
+    }
+
+    unless existing_test_case.present?
+      logger.info "Test Case: Creating new test case"
+
+      connection.post do |request|
+        request.url test_case_endpoint
+        request.headers["Content-Type"] = "application/json"
+        request.body = payload.to_json
+      end
+    else
+      logger.info "Test Case: Updating case #{test_case.slug}"
+
+      payload[:id] = test_case_id
+
+      connection.put do |request|
+        request.url test_case_endpoint(test_case.slug)
+        request.headers["Content-Type"] = "application/json"
+        request.body = payload.to_json
+      end
+    end
+
+  rescue Faraday::Error::ClientError => e
+    puts e.response
+  end
+
+  def fetch_test_case(slug)
+    connection.get(test_case_endpoint(slug)).body
+  rescue Faraday::Error::ResourceNotFound
+    nil
+  end
+
+  def create_test_run(test_case_slug, description="")
+    connection.post(test_run_endpoint(nil), {
+      test_case: test_case_slug,
+      test_run: { description: description }
+    }).body
+  end
+
+  def fetch_test_run(id)
+    response = connection.get(test_run_endpoint(id)).body
+
+    return unless response
+
+    response["test_runs"][0]
+  rescue Faraday::Error::ResourceNotFound
+    nil
+  end
+
+  def list_test_runs(test_case_slug=nil)
+    connection.get(test_run_endpoint, test_case: test_case_slug).body
+  end
+
+  def abort_test_run(id)
+    connection.post(test_run_abort_endpoint(id)).body
+  end
+
+  def fixture_upload(fixture)
+    logger.info "Uploading file #{fixture.name.to_s}..."
+
+    payload = { fixture: {
+      name: fixture.name.to_s,
+      file: Faraday::UploadIO.new(fixture.source, "text/plain")
+    }}
+
+    connection.post do |request|
+      request.url fixture_endpoint
+      request.headers["Content-Type"] = "multipart/form-data"
+      request.body = payload
+    end
+
+  rescue Exception => e
+    puts "Error while uploading '#{fixture.name.to_s}' ('#{fixture.source}')"
+    puts e.message
+  end
+
+  def fixture_exists?(md5_hash)
+    endpoint = "#{fixture_endpoint}/by_md5/#{md5_hash}.json"
+    connection.get(endpoint).status == 200
+  rescue Faraday::Error::ResourceNotFound
+    false
+  end
+
+
+
+  private
+
+  def test_case_endpoint(slug=nil)
+    "#{url_base}/test_cases#{slug ? "/#{slug}" : ""}"
+  end
+
+  def test_run_endpoint(id=nil)
+    "#{url_base}/test_runs/#{id}"
+  end
+
+  def test_run_abort_endpoint(id)
+    "#{url_base}/test_runs/#{id}/abort"
+  end
+
+  def fixture_endpoint
+    "#{url_base}/fixtures"
+  end
+
+  def authentication_endpoint
+    "#{url_base}/auth/token"
+  end
+
+  def resource_exists?(endpoint)
+    get(endpoint).response_code == 200
+  end
+
+  def logger
+    return @logger if @logger
+
+    @logger = Logger.new(STDOUT)
+    @logger.level = Logger::WARN
+    @logger
+  end
+end

data/lib/stormforge/dsl.rb

@@ -0,0 +1,4 @@
+module StormForge
+  module Dsl
+  end
+end

data/lib/stormforge/dsl/test_case.rb

@@ -0,0 +1,9 @@
+module StormForge
+  module Dsl
+    class TestCase
+      def self.define(*args, &block)
+        Definition.new(*args, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module StormForge::Dsl::TestCase::AttributeAccess
+  def method_missing(meth, *args, &block)
+    if available_attributes.include? meth
+      case args.size
+      when 0 then @attributes[meth]
+      when 1 then @attributes[meth] = args.first
+      else raise ArgumentError
+      end
+    elsif available_attributes.map {|a| "#{a}=".to_sym }.include? meth
+      @attributes[meth.to_s.split("=").first.to_sym] = args.first
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(meth, *args, &blk)
+    available_attributes.include? meth
+  end
+end

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

@@ -0,0 +1,33 @@
+class StormForge::Dsl::TestCase::Cloud
+  include ActiveModel::Serializers::JSON
+  include ActiveModel::Validations
+  include ::StormForge::Dsl::TestCase::AttributeAccess
+
+  self.include_root_in_json = false
+
+  attr_reader :attributes
+
+  validates :provider, :inclusion => { in: Proc.new { supported_cloud_providers } }
+
+  def initialize(provider, callable=nil, &block)
+    @attributes = {}
+
+    @attributes[:provider] = provider.to_sym
+    @attributes[:security_groups] = []
+
+    instance_eval(&(callable || block))
+  end
+
+  def security_groups(*groups)
+    @attributes[:security_groups] += groups
+  end
+  alias_method :security_group, :security_groups
+
+  def available_attributes
+    [ :provider ]
+  end
+
+  def self.supported_cloud_providers
+    [ :aws ]
+  end
+end

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

@@ -0,0 +1,49 @@
+class StormForge::Dsl::TestCase::DataSource
+
+  class << self
+    def build_marker(base_type, args)
+      "${#{base_type}|#{args_to_param(args)}}"
+    end
+
+    private
+
+    def args_to_param(args)
+      args.each_pair.map { |key, value| "#{key}=#{value}" }.join("-")
+    end
+  end
+
+  def initialize(callable=nil, &block)
+    @data_sources = {}
+
+    instance_eval(&(callable || block))
+  end
+
+  def random_string(name, options)
+    @data_sources[name] = RandomString.new(name, options)
+  end
+
+  def random_number(name, options)
+    @data_sources[name] = RandomNumber.new(name, options)
+  end
+
+  def file(name, options)
+    @data_sources[name] = FileFixture.new(name, options)
+  end
+
+  def file_fixture_sources
+    @data_sources.each_with_object({}) do |(name, source), memo|
+      memo[name] = source if source.instance_of? FileFixture
+    end
+  end
+
+  def sources
+    @data_sources
+  end
+
+  def serializable_hash(*args)
+    @data_sources.each_with_object({}) do |(name, data_source), hash|
+      hash[name] = data_source
+    end
+  end
+
+end

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

@@ -0,0 +1,104 @@
+class StormForge::Dsl::TestCase::DataSource::FileFixture
+
+  class ItemProxy
+    attr_reader :base_args, :fields
+
+    def initialize(base_args, fields)
+      @base_args = base_args
+      @fields = fields
+    end
+
+    def method_missing(meth, *args, &blk)
+      if fields.include? meth
+        StormForge::Dsl::TestCase::DataSource.build_marker("FILEFIXTURE", {
+          f: meth
+        }.merge(base_args))
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(meth, include_private = false)
+      fields.include?(meth) || super
+    end
+  end
+
+
+  include ActiveModel::Validations
+  include ActiveModel::Serializers::JSON
+  include ::StormForge::Dsl::TestCase::AttributeAccess
+
+  self.include_root_in_json = false
+
+  attr_reader :attributes
+
+  validates :name, presence: true
+  validates :source, presence: true
+  validates :order, inclusion: { in: [:randomly, :sequentially] }
+
+  class FixtureSourceValidator < ActiveModel::Validator
+    def validate(record)
+      if record.source.nil?
+        record.errors[:source] << "Source file must be set"
+      elsif !File.exist?(record.source)
+        record.errors[:source] << "Source file must exist"
+      end
+    end
+  end
+
+  validates_with FixtureSourceValidator
+
+  def initialize(name, options)
+    @attributes = {
+      name: name
+    }.merge(options)
+
+    unless @attributes[:simple_file]
+      @attributes[:order] = :sequentially unless @attributes[:order]
+      @attributes[:delimiter] = ";" unless @attributes[:delimiter]
+    end
+
+    @sequence = 0
+  end
+
+  def available_attributes
+    [
+      :name,
+      :source,
+      :fields,
+      :delimiter,
+      :order,
+      :simple_file
+    ]
+  end
+
+  def md5_hash
+    ::Digest::MD5.file(self.source).hexdigest if File.exist? self.source
+  end
+
+  def as_json(*args)
+    hash = super
+    hash[:type] = "file_fixture"
+    hash[:md5_hash] = self.md5_hash
+    hash[:source] = File.basename(self.source)
+    hash
+  end
+
+  def next
+    args = {
+      n: name,
+      seq: (@sequence += 1)
+    }
+
+    if fields.present?
+      ItemProxy.new(args, fields)
+    else
+      StormForge::Dsl::TestCase::DataSource.build_marker("FILEFIXTURE", args)
+    end
+  end
+
+  def count
+    @sequence
+  end
+end
+