kymera 0.1.0

data/Gemfile

@@ -0,0 +1,13 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in kymera.gemspec
+gem 'cucumber'
+gem 'ffi-rzmq'
+gem 'chronic'
+gem 'mongo', '1.10.2'
+gem 'bson', '1.10.2'
+gem 'bson_ext', '1.10.2'
+
+gemspec
+
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 jakesa
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+# Kymera
+
+Kymera is a distributed system built on ZeroMQ for running Cucumber tests across a network.
+If you are at this page, first let me say Thank You for your interest.  That being said, the Kymera gem
+is in a very early stage of development and is currently build specifically for use in DAT Solutions© internal testing infrastructure.
+I plan to make this more generic so it can be used with other systems, but for now the goal is to get something working for DAT Solutions©
+If you are still are interested, please download the source code and hack away.
+
+Also, please note that there are no reliable unit tests for this code yet.  It is on my TODO list but not a very high priority. In addition, the code is rather
+poorly annotated. My apologies for this. I will get to that as soon as I can.
+
+
+
+##Architecture
+The Kyemra gem is comprised of 5 components:
+
+###Client
+The client is the main entry point into the gem. This allows users to submit run requests to the framework. It is responsible for parsing the tests
+and sending them out to the Broker
+
+###Broker
+The broker is the component that is responsible for creating and maintaining the test execution queues. When a queue is spawned, the tests are sent to the
+ connected workers in a round-robin format. When a worker signals that it is available for test execution, the broker will send it a test to run.
+
+###Worker
+The worker is the component that is responsible for actually running the tests. As the tests are ran, the worker will publish its output to the results bus. When
+the test is completed it will send the entire output of that run to the test results collector for processing
+
+###Results Collector
+The result collector is responsible for taking all of the results from a test run, aggregating them and sending those results back to the client
+Optionally, the collector can also send a complete version of the results, parsed into html, to a mongodb database for reporting purposes.
+
+###Results Bus
+The Results Bus is where all the results are published. The Client listens on this bus for both real time output of the test run as well as the signal
+that the test run has completed.
+
+## Installation
+Please note that at the time of this writing, this gem has not been published. You will need to pull a copy of the repo and build the gem yourself
+
+    $ gem install kymera
+
+This gem uses ZeroMQ. It will need to be installed. You can find the installation instructions on their website [here](http://zeromq.org/intro:get-the-software)
+
+## Usage
+
+After installation is complete, you will need to generate the kymera_config.yaml file for gem configuration. This should be done in the same location
+as you Cucumber project. For convenience, there is a command line tool included with the gem. To generate the config file enter the following command
+
+    $ kymera config
+
+By default, the gem is setup to run everything locally and has the mongodb feature turned off.  Before you can use the Kymera system, the following components
+must be running:
+* Broker
+* Results Collector
+* Results Bus
+* At least one worker
+
+They can be started individually or all at once:
+
+All at once
+
+    $ kymera broker collector bus worker
+
+Individually
+
+    $ kymera broker
+    $ kymera collector
+
+
+Once all the necessary processes are started, you can start the a test run by calling the #run_tests method on the Kymera module
+
+    $ Kymera.run_tests('\Path\to\tests', 'cucumber', [-p default], 'develop', false)
+
+
+The run_tests method takes the following parameters
+* Test path -
+     This can be a path to a specific test or a path to a directory of tests. The system will parse all of the feature files for
+     tests it is supposed to run based on the run options passed in.
+* Test runner -
+     This is the runner that they system is to use for running the tests. At the time of this writing, the only supported running is cucumber
+* Runner options -
+     These are the options to be passed to the runner and what will be used to parse the tests to be executed.
+* Branch name -
+     When a test is started on a worker, it pulls the specified branch for any changes and updates before running the test. This parameter tells it the branch
+     name
+* Live results -
+     This parameter tells the system whether or not to display real time results. By default it is set to true. If set to false, there will be no console output
+     to the client until the run has been completed
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/kymera

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+require 'kymera'
+
+args = ARGV
+threads = []
+trap ("INT") do
+  puts "\nStopping Kymera processes..."
+  threads.each do |thread|
+    thread.kill
+  end
+end
+
+
+  if args.length > 1
+    args.each do |arg|
+      case arg
+        when "broker"
+          threads << Thread.new {Kymera.start_broker}
+        when "bus"
+          threads << Thread.new {Kymera.start_bus}
+        when "collector"
+          threads << Thread.new {Kymera.start_collector}
+        when "worker"
+          threads << Thread.new {Kymera.start_worker}
+        when "config"
+          threads << Thread.new {Kymera.generate_config}
+        else
+          threads.each do |thread|
+            thread.kill
+          end
+
+          raise "No valid parameters were passed in. Here is a list of the valid parameters:\nbroker\nbus\ncollector\nworker\nconfig\n"
+      end
+    end
+
+  else
+    case args[0]
+      when "broker"
+        threads << Thread.new {Kymera.start_broker}
+      when "bus"
+        threads << Thread.new {Kymera.start_bus}
+      when "collector"
+        threads << Thread.new {Kymera.start_collector}
+      when "worker"
+        threads << Thread.new {Kymera.start_worker}
+      when "config"
+        threads << Thread.new {Kymera.generate_config}
+      else
+        threads.each do |thread|
+          thread.kill
+        end
+
+        raise "No valid parameters were passed in. Here is a list of the valid parameters:
+              broker\nbus\ncollector\nworker\nconfig\n"
+    end
+
+  end
+
+
+threads.each do |thread|
+  thread.join
+end
+

data/kymera.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kymera/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kymera"
+  spec.version       = Kymera::VERSION
+  spec.authors       = ["jakesa"]
+  spec.email         = ["jakes.sarate@dat.com"]
+  spec.description   = 'Distributed Cucumber test runner'
+  spec.summary       = 'Execute cucumber tests across a network'
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_dependency 'cucumber'
+  spec.add_dependency 'ffi-rzmq'
+  spec.add_dependency 'json'
+  spec.add_dependency 'mongo', '1.10.2'
+  spec.add_dependency 'bson', '1.10.2'
+  spec.add_dependency 'bson_ext', '~> 1.10.0'
+  spec.add_dependency 'chronic'
+
+end

data/lib/kymera/broker.rb

@@ -0,0 +1,112 @@
+require_relative 'szmq/szmq'
+require 'json'
+
+module Kymera
+
+  class Broker
+
+    #test_address is the port you want to listen on for incoming test runs. client_address is the internal address used for sending tests to the proxy
+    #worker_address is the port that the workers will connect to for test distribution. num_of_con is the number of concurrent requests you want running at any given time
+    #This number can be tuned depending on the machine the broker is running on.
+    def initialize
+      config = Kymera::Config.new
+      @zmq = Kymera::SZMQ.new
+      @num_of_connections = config.broker["number_of_connections"]
+      #This socket is for getting tests from the client
+      @client_address = "tcp://*:#{config.broker["client_listening_port"]}"
+      @internal_address = "tcp://*:#{config.broker["internal_worker_port"]}"
+      @worker_address = "tcp://*:#{config.broker["worker_listening_port"]}"
+      @test_socket = @zmq.socket(@client_address, 'pull')
+      @test_socket.bind
+      @front_end = @zmq.socket(@internal_address, 'router')
+      @back_end = @zmq.socket(@worker_address, 'dealer')
+      @proxy = Thread.new {@zmq.start_proxy(@front_end, @back_end)}
+    end
+
+    #This brings up the broker so that it can receive test run requests.
+    def start_broker
+      puts "Broker started..."
+      @test_socket.receive do |tests|
+        puts "Received test run request.."
+        start_test_run(tests)
+      end
+    end
+
+    private
+
+    #This is the start of the test run and is called when the broker receives a test run request
+    def start_test_run(test_run)
+      test_run = JSON.parse(test_run)
+      @test_count = test_run["tests"].length
+      tests = test_run["tests"]
+      threads = []
+
+      report_test_config(test_run)
+
+      if tests.length > @num_of_connections.to_i
+        1.upto @num_of_connections do
+          test = tests.pop
+          break if test.nil?
+          threads << run_test(test, test_run)
+        end
+        work_queue(threads, tests, test_run)
+        puts "Tests Complete"
+
+      else
+        1.upto tests.length do
+          test = tests.pop
+          break if test.nil?
+          threads << run_test(test, test_run)
+        end
+        threads.each do |t|
+          t.join
+        end
+        puts "Tests Complete"
+
+      end
+
+
+    end
+
+    #If there are tests left over after the initial test start up, they are placed into a queue.  The queue is then worked until all tests in the queue have been executed
+    def work_queue(threads, tests, options)
+      until tests.empty?
+        threads.delete_if {|t| !t.alive?}
+        if threads.length < @num_of_connections
+          test = tests.pop
+          break if test.nil?
+          threads << run_test(test, options)
+        end
+      end
+      threads.each do |t|
+        t.join
+      end
+    end
+
+    #This runs each test individually
+    def run_test(test, options)
+      port = @internal_address.split(':')[2]
+      Thread.new {
+        message = JSON.generate({:test => test, :runner => options["runner"], :options => options["options"], :run_id => options["run_id"],
+                                 :test_count => @test_count, :branch => options["branch"], :start_time => options["start_time"]})
+        socket = @zmq.socket("tcp://127.0.0.1:#{port}", 'request')
+        socket.connect
+        puts "Sending: #{message}"
+        socket.send_message(message)
+        socket.close}
+    end
+
+    #This gives a print out of the test run that was received
+    def report_test_config(test_run)
+      puts "Running test with the following configuration:"
+      puts "Branch: #{test_run["branch"]}"
+      puts "Runner: #{test_run["runner"]}"
+      puts "Run ID: #{test_run["run_id"]}"
+      puts "Runner Options: #{test_run["options"]}"
+      puts "Total number tests: #{test_run["tests"].length}"
+    end
+
+
+  end
+
+end

data/lib/kymera/client.rb

@@ -0,0 +1,98 @@
+require_relative 'szmq/szmq'
+require 'json'
+
+module Kymera
+
+  class Client
+
+    #The client is responsible for sending the run to the distributed network. It is responsible for parsing the tests and sending all needed information to the
+    #test broker
+    #The initializer take in a broker_address(String) identifying the location of the broker on the network, a results_bus_address(String) identifying the latching point of the bus where the client and get
+    #real-time test output as the tests are being executed and real_time(Boolean) indicating whether or not this client wants to get real-time updates. This is defaulted to true
+    def initialize(real_time = true)
+      config = Kymera::Config.new
+      @broker_address = config.client["broker_address"]
+      @results_bus_address = config.client["results_bus_address"]
+      @real_time = real_time.to_s
+      @zmq = Kymera::SZMQ.new
+      @client_id = Kymera::host_name
+      Client.run_id +=1
+      @full_run_id = @client_id + (Client.run_id.to_s)
+    end
+
+    def self.run_id=(num)
+      @run_id = num
+    end
+
+    def self.run_id
+      @run_id ||= 0
+    end
+
+
+    #This is the kick off point for the test run. The tests parameter is the directory location of the tests you wish to run. This will be passed into a test parser that will determine
+    #which of the tests in the directory need to be run based on the options passed in.  The runner parameter tells the system which test runner the system should use. Right now, the only
+    #supported test runner is Cucumber, but I would like to expand this at the very least to also support Rspec.  The options parameter are the options to be passed into the specified runner
+    def run_tests(tests, runner, options, branch = 'develop')
+      @start_time = Time.now
+      tests = parse_tests(tests, runner, options)
+      test_run = {:tests => tests, :runner => runner, :run_id => @full_run_id, :options => options, :branch => branch, :start_time => @start_time.to_s }
+      socket = @zmq.socket(@broker_address, 'push')
+      socket.connect
+      message = JSON.generate(test_run)
+      socket.send_message(message)
+
+      channels = ["end_#{@full_run_id}"]
+      results_feed = @zmq.socket(@results_bus_address, 'sub')
+      if @real_time == "true"
+        channels << @full_run_id
+      end
+      results_feed.subscribe(channels) do |channel, results|
+        if channel == "end_#{@full_run_id}"
+          puts "###########Test Run Results########################"
+          puts results
+          results_feed.close
+          report_time_taken
+          exit
+        else
+          puts results
+        end
+      end
+
+    end
+
+    private
+
+    #This method is what parses the test directory into runnable tests. It takes in 3 parameters, the first being tests(String). This is the location for which the system looks for
+    #executable tests. This can also be a single test. The system will still parse it to make sure that it should be run based on the passed in options.  The runner(String) tells the
+    #parser which test parser to use. Currently there is only support for a cucumber parser.  I hope to expand support for Rspec as well. The options(Array), are the options that the
+    #test parser should use for parsing out the tests.
+    def parse_tests(tests, runner, options)
+
+      test_path = nil
+      if Kymera.is_linux?
+        if tests.include? 'c:'
+          test_path = tests.gsub('c:','~')
+        else
+          test_path = tests.gsub('C:','~')
+        end
+      else
+        test_path = tests
+      end
+
+
+      if runner.downcase == 'cucumber'
+        parser = Kymera::Cucumber::TestParser.new(test_path, options)
+        parser.parse_tests
+      end
+    end
+
+    def report_time_taken
+      run_time = ((Time.now - @start_time)/60).to_s.match(/(\d+.\d{2})/)[0]
+      puts "Took #{run_time}m"
+    end
+
+  end
+
+
+
+end

data/lib/kymera/config/config.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+module Kymera
+  class Config
+
+    #The constructor reads in the config.yaml file, converts it into a hash and then defines methods on this class based on the
+    #different sections
+    def initialize
+      yaml_file = File.open(File.join(Dir.pwd, '/kymera_config.yaml'), 'r+')
+      yaml_file.rewind
+      @config_options = YAML.load(yaml_file.read)
+      @config_options.each do |key, value|
+        define_singleton_method(key){value}
+      end
+      yaml_file.close
+    end
+
+    #This takes any changes that were made to the different sections and updates the config.yaml file (more to the point, overrides the old file
+    # and replaces the entire file with the new values)
+    def update
+      yaml_file = File.open(File.join(Dir.pwd, '/kymera_config.yaml'), 'w+')
+      @config_options.to_yaml.split('\n').each do |line|
+        yaml_file.write(line)
+      end
+      yaml_file.rewind
+      str = yaml_file.read
+      yaml_file.close
+      str
+    end
+
+    def to_s
+      @config_options.to_yaml
+    end
+
+
+  end
+end

data/lib/kymera/cucumber/cucumber_html_parser.rb

@@ -0,0 +1,80 @@
+
+module Kymera
+  module Cucumber
+    class HTMLResultsParser
+      def self.to_html(results)
+        html_results = ''
+        results_array = results.split("\n")
+
+        if results_array.length < 3
+          html_results << "<div class='summary'>"
+          results_array.each do |line|
+            line.gsub!("\e[36m", "<span class='skip'>")
+            line.gsub!("\e[90m", "<span class='text'>")
+            line.gsub!("\e[31m", "<span class='error'>")
+            line.gsub!("\e[32m", "<span class='pass'>")
+            line.gsub!("\e[1m", "<span class='example'>")
+            line.gsub!("\e[0m", "</span>")
+            line.gsub!("[36m", "<span class='skip'>")
+            line.gsub!("[90m", "<span class='text'>")
+            line.gsub!("[31m", "<span class='error'>")
+            line.gsub!("[32m", "<span class='pass'>")
+            line.gsub!("[1m", "<span class='example'>")
+            line.gsub!("[0m", "</span>")
+            html_results << "#{line}<br>"
+          end
+          html_results << "</div>"
+          html_results
+        else
+
+          results_array.each do |line|
+            if line.start_with?("Using")
+              if html_results == ''
+                html_results << "<div class='feature'>"
+                html_results << "<p>"
+                html_results << "#{line}"
+              else
+                html_results << "</p></div>"
+                html_results << "<div class='feature'>"
+                html_results << "<p>"
+                html_results << "#{line}"
+              end
+            elsif line.start_with?("Feature")
+              html_results << "<span class='featureTitle'>#{line}</span><br>"
+            elsif line.lstrip.start_with?("Scenario")
+              line.gsub!("\e[90m", "<span class='text'>")
+              line.gsub!("[90m", "<span class='text'>")
+              line.gsub!("\e[0m", "</span>")
+              line.gsub!("[0m", "</span>")
+              html_results << "<span class='scenarioTitle'>#{line}</span><br>"
+            else
+              #\e[36m blue
+              #\e[90m gray
+              #\e[31m red
+              #\e[32m green
+              #\e[0m
+              line.gsub!("\e[36m", "<span class='skip'>")
+              line.gsub!("\e[90m", "<span class='text'>")
+              line.gsub!("\e[31m", "<span class='error'>")
+              line.gsub!("\e[32m", "<span class='pass'>")
+              line.gsub!("\e[1m", "<span class='example'>")
+              line.gsub!("\e[0m", "</span>")
+              line.gsub!("[36m", "<span class='skip'>")
+              line.gsub!("[90m", "<span class='text'>")
+              line.gsub!("[31m", "<span class='error'>")
+              line.gsub!("[32m", "<span class='pass'>")
+              line.gsub!("[1m", "<span class='example'>")
+              line.gsub!("[0m", "</span>")
+              html_results << "#{line}<br>"
+            end
+          end
+          html_results << "</div>"
+          html_results
+
+        end
+
+      end
+    end
+  end
+end
+

data/lib/kymera/cucumber/cucumber_results_parser.rb

@@ -0,0 +1,93 @@
+module Kymera
+  module Cucumber
+    class ResultsParser
+
+      #TODO: JS - Add support for detecting skipped/undefined steps
+      def self.parse
+        @results
+      end
+
+      def self.summarize_results(results)
+        results_array = results.split("\n")
+        sort_order = %w[scenario step]
+        aggregate_results = sort_order.map do |group|
+          r_group_results = results_array.select {|l| l2 = l.scan(/^\d+ #{group}/); !l2.empty?}
+          sum_up_lines(r_group_results, group)
+        end.compact.join("\n")
+        aggregate_results << "\n#{sum_up_failed_scenarios(results_array)}"
+      end
+
+      def self.sum_up_lines(lines, group)
+        r_lines =[]
+        lines.each do |l|
+          r_lines << l.gsub('(','').gsub(')','')
+        end
+
+        _group, group_count, passed, passed_count, failed, failed_count = ''
+
+        group_lines = r_lines.map {|m| m.scan(/(\d+) (#{group})/)}
+        _group, group_count = count(group_lines) unless group_lines.empty?
+
+        failed_scenarios = r_lines.map {|m| m.scan(/(\d+) (failed)/)}
+        failed_scenarios.delete_if {|l| l.empty?}
+        failed, failed_count = count(failed_scenarios) unless failed_scenarios.empty?
+
+        passed_scenarios = r_lines.map {|m| m.scan(/(\d+) (passed)/)}
+        passed_scenarios.delete_if {|l| l.empty?}
+        passed, passed_count = count(passed_scenarios) unless passed_scenarios.empty?
+
+        if group_count > 1
+          _group += 's'
+        end
+
+        if _group.downcase.include? 'scenario'
+          @@p_count = ''
+          @@f_count = ''
+          @@p_count = passed_count unless passed_count.nil?
+          @@f_count = failed_count unless failed_count.nil?
+        end
+
+        if failed_scenarios.empty?
+          "#{group_count} #{_group} (\e[32m#{passed_count} #{passed}\e[0m)"
+        elsif passed_scenarios.empty?
+          "#{group_count} #{_group} (\e[31m#{failed_count} #{failed}\e[0m)"
+        else
+          "#{group_count} #{_group} (\e[31m#{failed_count} #{failed}\e[0m, \e[32m#{passed_count} #{passed}\e[0m)"
+        end
+
+      end
+
+      #These variables are reset every time the sum_up_lines method is called
+      def self.scenario_counts
+        {pass: @@p_count, fail: @@f_count}
+      end
+
+
+      def self.count(lines)
+        count = 0
+        word = ''
+        lines.each do |l|
+          count += l[0][0].to_i
+          word = l[0][1]
+        end
+        [word, count]
+      end
+
+      def self.sum_up_failed_scenarios(results)
+        results = results.select{|l| l.include?('[31mcucumber')}
+        if results.empty?
+          ''
+        else
+          results.map {|l| l << "\n"}
+          formatted_results = "\e[31mFailing Scenarios:\n"
+          results.each {|l| formatted_results << l}
+          formatted_results << "\e[0m"
+          formatted_results
+        end
+      end
+
+    end
+
+  end
+
+end