greenlight 0.0.1.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 456a4b33aa62487e1ceff2c2f08c13ed707c966f
+  data.tar.gz: e76bba99e28a32911d5540e7b54b78223b0e38c4
+SHA512:
+  metadata.gz: dcd8b0b3ce263b5d92e5ecba6d930df802e2f612179477487f7e11dff404d83a5d9f0e316a4c856e11fe57f2d0a87b85976e9ecdeda3d003a95b164e636c9bdc
+  data.tar.gz: 92e78e6c8e0ce65b19ee4e1c31dc6c53d76230b7a398d9d71b24358cb639bd7ad51111c4a5e6612c834230bfed2c5011e1e9098e72d47eb994cad805a6a28a97

data/lib/greenlight/console.rb

@@ -0,0 +1,92 @@
+require 'singleton'
+
+class Colors
+
+	COLORS_LIB = {
+			:red => '31',
+			:green => '32',
+			:yellow => '33',
+			:blue => '34',
+			:grey => '37',
+			:magenta => '35',
+			:cyan => '36',
+			:light_cyan => '96',
+			:light_red => '91',
+			:light_blue => '94',
+			:light_magenta => '95',
+			:light_green => '92',
+			:light_yellow => '93',
+			:white => '97'
+
+	}
+	class << self
+		COLORS_LIB.each do |color_name, color_val|
+			define_method(color_name.to_s) { |msg|
+				$stdout.tty? ? "\e[#{color_val}m#{msg}\e[0m" : msg
+			}
+		end
+	end
+
+end
+
+class Console
+
+	include Singleton
+
+	attr_accessor :indent_level
+
+	INDENT_STR = '  '
+
+	def initialize
+		self.indent_level = 0
+	end
+
+	def info(msg)
+		puts Colors.grey(' - ' + get_indent + msg)
+	end
+
+	def action(msg)
+		puts ' * ' + get_indent + msg
+	end
+
+	def error(msg)
+		puts Colors.light_red(' ' + Console.utf8("\u2718") + ' ' + get_indent + msg)
+	end
+
+	def success(msg)
+		puts Colors.light_green(' ' + Console.utf8("\u2713") + ' ' + get_indent + msg)
+	end
+
+	def get_indent
+		INDENT_STR * indent_level
+	end
+
+	def indent
+		self.indent_level = self.indent_level + 1
+	end
+
+	def unindent
+		self.indent_level = self.indent_level - 1 unless self.indent_level == 0
+	end
+
+	def self.utf8(code)
+		code.encode('utf-8')
+	end
+end
+
+
+def info(msg)
+	Console.instance.info(msg)
+end
+
+def action(msg)
+	Console.instance.action(msg)
+end
+
+def error(msg)
+	Console.instance.error(msg)
+end
+
+def success(msg)
+	Console.instance.success(msg)
+end

data/lib/greenlight/injector.rb

@@ -0,0 +1,25 @@
+require 'singleton'
+
+class Injector
+  include Singleton
+
+  attr_accessor :headers
+
+  def initialize
+    self.headers = {}
+  end
+
+  def add_header(header, value)
+    self.headers[header] = value
+  end
+
+  def rm_header(header)
+    self.headers.delete(header)
+  end
+
+  def self.decorate(options)
+    options[:headers] = {} unless (options.key?(:headers) && options[:headers].is_a?(Hash))
+    options[:headers].merge!(Injector.instance.headers)
+    options
+  end
+end

data/lib/greenlight/request.rb

@@ -0,0 +1,168 @@
+require 'typhoeus'
+require 'json'
+
+require 'greenlight/injector'
+require 'greenlight/console'
+
+module Greenlight
+
+  class RequestException < StandardError; end
+  class AssertionException < StandardError; end
+
+  class RequestResponse
+    attr_accessor :body, :headers, :raw_body, :total_time, :code
+  end
+
+  class Request
+
+    # request description
+    attr_accessor :url, :options
+
+    # request response
+    attr_accessor :response
+
+    # response structure with json parsed body
+    attr_accessor :req_response
+
+    # request assertions
+    attr_accessor :expectations
+
+    # count assertions to report the index of the failed one
+    attr_accessor :assert_no
+
+
+    def initialize(url, options)
+      self.url = url
+      self.options = options
+      self.expectations = []
+    end
+
+    # define list of expectations (assertions)
+    def expect(&block)
+      self.expectations = block
+      run
+    end
+
+    def _debug_info
+      if code != 0
+        info "response status code: #{code}"
+      else
+        info "library returned: #{response.return_code}"
+      end
+      info "request body: #{options[:body]}"
+      info "request headers: #{options[:headers]}"
+      info "response body: #{body}"
+      info "response headers: #{response.headers}"
+
+    end
+
+    # define assertion
+    def assert(condition)
+      unless condition
+        error "assertion no. #{assert_no} failed"
+        _debug_info
+        raise AssertionException
+      end
+
+      self.assert_no = assert_no + 1
+    end
+
+    # assertion helpers
+    def header(name)
+      response.headers[name]
+    end
+
+    def headers
+      response.headers
+    end
+
+    def code
+      response.code
+    end
+
+    def raw_body
+      response.body
+    end
+
+    def body
+      req_response.body
+    end
+
+    def total_time
+      response.total_time
+    end
+
+    # run the request and evaluate expectations
+    def run
+
+      action Colors.grey("REQUEST ") + Colors.light_blue("#{options[:method].upcase} #{url}")
+      Console.instance.indent
+      # run the request
+      options[:ssl_verifypeer] = false
+      options[:followlocation] = true
+
+      Injector.decorate(options)
+
+      # convert all headers keys to strings to avoid having symbols like :"header" when
+      # declaring headers with colons instead of arrows
+      if options.key?(:headers)
+        new_opts = {}
+        options[:headers].map do |k, v|
+          new_opts[k.to_s] = v
+        end
+        options[:headers] = new_opts
+      end
+
+      if options.key?(:headers) and options[:headers].key?('Content-Type')
+        ctype = options[:headers]['Content-Type']
+        if ctype.include?('application/json')
+          # automatically encode json content
+          options[:body] = JSON.generate(options[:body], quirks_mode: true)
+        end
+      end
+
+
+
+      self.response = Typhoeus::Request.new(url, options).run
+
+      self.req_response = RequestResponse.new.tap { |r|
+        r.raw_body = response.body
+        r.headers = response.headers
+        r.code = response.code
+        r.total_time = response.total_time
+
+        if !r.headers.nil? && r.headers.key?('Content-Type') && r.headers['Content-Type'].include?('application/json')
+          r.body = JSON.parse(response.body)
+        else
+          r.body = response.body
+        end
+      }
+
+      # reset assertion counter
+      self.assert_no = 1
+
+      # evaluate response against expectations
+      begin
+        instance_eval(&expectations)
+      rescue AssertionException
+        error error_msg + " at #{expectations.source_location}"
+        raise RequestException
+      rescue StandardError => e
+        error 'Exception ' + e.message
+        info e.backtrace.inspect
+        _debug_info
+        error error_msg
+        raise RequestException
+      ensure
+        Console.instance.unindent
+      end
+
+      req_response
+
+    end
+
+    def error_msg
+      "REQUEST '#{options[:method].upcase} #{url}' failed"
+    end
+  end
+end

data/lib/greenlight/scenario.rb

@@ -0,0 +1,48 @@
+require 'greenlight/console'
+require 'greenlight/request'
+require 'greenlight/test'
+
+module Greenlight
+
+  class ScenarioException < StandardError; end
+
+  class Scenario
+
+    # tests - hash of tests
+    attr_accessor :name, :body
+
+    def initialize(name, &block)
+      self.name = name
+      self.body = block
+    end
+
+    def run
+      action Colors.white("SCENARIO ") + Colors.light_magenta(name)
+      Console.instance.indent
+      ret = Greenlight.eval({}, &body)
+      success('scenario succeeded')
+      ret
+    rescue RequestException
+      error error_msg
+      raise ScenarioException
+    rescue TestException
+      error error_msg
+      raise ScenarioException
+    rescue LibraryException
+      error error_msg
+      raise ScenarioException
+    rescue StandardError => e
+      error e.backtrace.inspect
+      error e.message
+      error error_msg
+      raise ScenarioException
+    ensure
+      Console.instance.unindent
+    end
+
+    def error_msg
+      "SCENARIO '#{name}' failed"
+    end
+  end
+
+end

data/lib/greenlight/test.rb

@@ -0,0 +1,45 @@
+require 'greenlight/console'
+require 'greenlight/request'
+require 'greenlight/library'
+
+module Greenlight
+  class TestException < StandardError; end
+
+  class Test
+    attr_accessor :name
+    attr_accessor :body
+    attr_accessor :args
+
+    def initialize(name, &block)
+      self.name = name
+      self.body = block
+    end
+
+    def run(args = {})
+      action Colors.white("TEST ") + Colors.yellow(name)
+      Console.instance.indent
+      begin
+        ret = Greenlight.eval(args, &body)
+        success('test succeeded')
+        ret
+      rescue RequestException
+        error error_msg
+        raise TestException
+      rescue LibraryException
+        error error_msg
+        raise TestException
+      rescue StandardError => e
+        error e.backtrace.inspect
+        error e.message
+        error error_msg
+        raise TestException
+      ensure
+        Console.instance.unindent
+      end
+    end
+
+    def error_msg
+      "TEST '#{name}' failed"
+    end
+  end
+end

data/lib/greenlight.rb

@@ -0,0 +1,164 @@
+require 'greenlight/console'
+require 'greenlight/request'
+require 'greenlight/test'
+require 'greenlight/scenario'
+require 'singleton'
+require 'yaml'
+require 'json'
+require 'typhoeus'
+
+module Greenlight
+  class Runner
+    include Singleton
+
+    attr_accessor :params, :data
+
+    ATLAS_ENV_PREFIX = 'greenlight'
+    ATLAS_ENV_SEPARATOR = '_'
+
+    private
+    def load_data_url(uri)
+      resp = Typhoeus::Request.new(uri, {}).run
+      if resp.code == 200
+        case resp.headers['Content-Type'].split(';')[0]
+        when 'application/json'
+          JSON.parse(resp.body)
+        when 'text/yaml'
+          YAML.load(resp.body)
+        else
+          error 'unsupported data file format; only json and yaml are supported'
+          error resp.headers['Content-Type'] + ' found'
+          failure
+        end
+
+      else
+        error "loading test data from #{uri} failed with code #{resp.code}"
+        failure
+      end
+
+    end
+
+    def load_data_file(uri)
+      ext = File.extname(uri)
+      case ext
+      when '.json'
+        JSON.parse(File.read(uri))
+      when '.yml'
+        YAML.load_file(uri)
+      else
+        error 'unsupported file format: ' + ext
+        error 'only .json and .yml are supported'
+      end
+    end
+
+    def env_override(env_var)
+      ptr = data
+      parts = env_var.split(ATLAS_ENV_SEPARATOR)
+      parts[1, parts.length - 2].each do |p|
+        if ptr[p].is_a? Hash
+          ptr = ptr[p]
+        else
+          ptr[p] = {}
+          ptr = ptr[p]
+        end
+      end
+
+      ptr[parts[parts.length - 1]] = ENV[env_var]
+    end
+
+    def load_env
+      ENV.keys.each do |k|
+
+        next unless k.start_with?(ATLAS_ENV_PREFIX + ATLAS_ENV_SEPARATOR)
+        env_override(k)
+
+      end
+    end
+
+    public
+
+    %w[post get options delete put patch].each do |method|
+      define_method(method.to_s) do |url, options = {}|
+        options[:url] = url
+        options[:method] = method.to_sym
+        req = Request.new url, options
+        req
+      end
+    end
+
+    def initialize
+      self.params = {}
+      self.data = {}
+    end
+
+    def load_data(uri, overwrite = false)
+      info "loading data from #{uri}"
+      if uri.start_with?('http://', 'https://')
+        new_data = load_data_url(uri)
+      else
+        new_data = load_data_file(uri)
+      end
+
+      if overwrite
+        self.data = new_data
+      else
+        self.data.merge!(new_data)
+      end
+
+      load_env
+      new_data
+    end
+
+    def test(name, &block)
+      Test.new(name, &block).run
+    end
+
+    def scenario(name, &block)
+      Scenario.new(name, &block).run
+    end
+
+    def add_header(header, value)
+      Injector.instance.add_header(header, value)
+    end
+
+    def rm_header(header)
+      Injector.instance.rm_header(header)
+    end
+
+    def add_headers(headers)
+      headers.each do |key, val|
+        Injector.instance.add_header(key, val)
+      end
+    end
+
+  end
+
+  def self.eval(params, &block)
+    runner = Runner.instance
+    runner.params = params
+    runner.instance_eval(&block)
+  end
+end
+
+def greenlight(&block)
+  begin
+    Greenlight.eval({}, &block)
+  rescue Greenlight::LibraryException
+    failure
+  rescue Greenlight::ScenarioException
+    failure
+  rescue Greenlight::TestException
+    failure
+  rescue Greenlight::RequestException
+    failure
+  rescue StandardError => e
+    info e.backtrace.inspect
+    error e.message
+    failure
+  end
+end
+
+def failure
+  error 'TEST RUN FAILED'
+  abort
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: greenlight
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre.alpha
+platform: ruby
+authors:
+- Florin Mihalache
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: A Ruby DSL to help writing automated tests for APIs.
+email: florin.mihalache@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/greenlight.rb
+- lib/greenlight/console.rb
+- lib/greenlight/injector.rb
+- lib/greenlight/request.rb
+- lib/greenlight/scenario.rb
+- lib/greenlight/test.rb
+homepage: http://github.com/mflorin/greenlight
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Automated Tests Language for APIs
+test_files: []