kymera 0.1.0

data/lib/kymera/worker.rb

@@ -0,0 +1,83 @@
+require_relative 'szmq/szmq'
+require 'json'
+
+module Kymera
+  class Worker
+
+    def initialize
+      config = Kymera::Config.new
+      @test_address = config.worker["broker_address"]
+      @results_address = config.worker["result_collector_address"]
+      @result_bus_address = config.worker["result_bus_address"]
+      @zmq = SZMQ.new
+      #For the moment I am using a push/pull configuration for running of tests.  Initial runs indicated that this may not work as all tests are being sent to just one
+      #worker at a time instead of load balancing them.  It may be more advantageous to use a request/reply structure for sending tests and managing the test run queue
+      #manually.
+      @test_socket = @zmq.socket(@test_address, 'reply')
+      @results_socket = @zmq.socket(@results_address, 'push')
+      @result_bus_socket = @zmq.socket(@result_bus_address, 'pub')
+      @result_bus_socket.connect
+      @test_socket.connect
+      #Even though this is a push socket, I am connecting instead of binding because the static point is going to be the pull socket where the results are aggregated
+      #Static points are bound, dynamic points are connected
+      @results_socket.connect
+    end
+
+    def listen
+      puts "Worker started..."
+      @test_socket.receive do |message|
+        #This is a preliminary kill command. I will need to give more thought into the life cycle of the workers
+        if message == 'STOP'
+          stop
+          break
+        else
+          results = run_test(message)
+          @results_socket.send_message(results)
+          @test_socket.send_message ''
+        end
+      end
+
+    end
+
+    #I need to pass in the runner and runner options. Thinking about using JSON to get those options and instantiate a runner object based on that information
+    #The idea is to be able to take in any number of different test runners (cucumber/rspec) without having the restart the worker object
+    #This is why passing in the runner on worker instantiation isnt really an option
+    def run_test(test)
+      test = JSON.parse(test)
+      runner = get_runner(test["runner"], test["options"], test["run_id"])
+      test_path = nil
+      if Kymera.is_linux?
+        if test["test"].include? 'c:'
+          test_path = test["test"].gsub('c:','~')
+        else
+          test_path = test["test"].gsub('C:','~')
+        end
+      else
+        test_path = test["test"]
+      end
+
+      results = runner.run_test(test_path, test['branch'])
+      JSON.generate({:run_id => test["run_id"], :test_count => test["test_count"], :runner => test["runner"], :results => results, :start_time => test["start_time"]} )
+    end
+
+    def stop
+      @test_socket.close
+      @results_socket.close
+    end
+
+    private
+
+    #TODO - I would like to add a way to dynamically add runners so that a user can custom build a runner and use it with this gem.
+    #Right now I am just doing some simple if/then logic to get predefined runners.
+    def get_runner(runner, options, run_id)
+      if runner.downcase == 'cucumber'
+        Kymera::Cucumber::Runner.new(options, run_id, @result_bus_socket)
+      else
+        nil
+      end
+    end
+
+
+  end
+end
+

data/lib/kymera.rb

@@ -0,0 +1,88 @@
+require 'ffi-rzmq'
+require_relative 'kymera/szmq/szmq'
+require_relative 'kymera/cucumber/cucumber_test_runner'
+require_relative 'kymera/worker'
+require_relative 'kymera/broker'
+require_relative 'kymera/client'
+require_relative 'kymera/cucumber/test_parser'
+require_relative 'kymera/results_bus'
+require_relative 'kymera/platform_utils'
+require_relative 'kymera/test_results_collector'
+require_relative 'kymera/cucumber/cucumber_results_parser'
+require_relative '../lib/kymera/cucumber/cucumber_html_parser'
+require_relative 'kymera/config/config'
+
+module Kymera
+
+  #Start a test run
+  def self.run_tests(tests, test_runner, options, branch, real_time = true)
+    Kymera::Client.new(real_time).run_tests(tests, test_runner, options, branch)
+
+  end
+
+  #Start the test broker
+  def self.start_broker
+    Kymera::Broker.new.start_broker
+  end
+
+  #Start a worker
+  def self.start_worker
+    Kymera::Worker.new.listen
+  end
+
+  #Start the results collector
+  def self.start_collector
+    Kymera::TestResultsCollector.new.listen
+  end
+
+  #Start the results bus
+  def self.start_bus
+    Kymera::ResultsBus.new.start_bus
+  end
+
+  #Generate the default config.yaml file
+  def self.generate_config
+    require 'yaml'
+    puts "Generating congfig.yaml"
+    config_options = {
+        "client" => {
+            "broker_address" => 'tcp://127.0.0.1:5550',
+            "results_bus_address" => 'tcp://127.0.0.1:7001'
+        },
+        "broker" =>{
+            "client_listening_port" => '5550',
+            "worker_listening_port" => '5552',
+            "internal_worker_port" => '5551',
+            "number_of_connections" => '20'
+
+        },
+        "worker" => {
+            'broker_address' => 'tcp://127.0.0.1:5552',
+            'result_collector_address' => 'tcp://127.0.0.1:5556',
+            'result_bus_address' => 'tcp://127.0.0.1:7000'
+        },
+        'result_collector' =>{
+            'inc_listening_port' => '5556',
+            'result_bus_address' => 'tcp://127.0.0.1:7000',
+            'send_mongo_results' => false,
+            'mongodb_address' => '127.0.0.1',
+            'mongodb_port' => 27017,
+            'mongodb_database_name' => 'default_db',
+            'mongodb_collection_name' => 'default_collection'
+
+        },
+        'result_bus' => {
+            'pub_port' => '7000',
+            'sub_port' => '7001'
+        }
+    }
+    puts Dir.pwd
+    puts File.join(Dir.pwd, '/kymera_config.yaml')
+    config_file = File.open(File.join(Dir.pwd, '/kymera_config.yaml'), 'w+')
+    config_options.to_yaml.split('\n').each do |line|
+      config_file.write(line)
+    end
+    config_file.close
+    config_options.to_yaml
+  end
+end

data/lib/spec/broker_spec.rb

@@ -0,0 +1,25 @@
+require 'ffi-rzmq'
+require_relative '../../lib/kymera'
+#require_relative '../../lib/kymera/v_3/kymera'
+#
+#broker = Kymera::Broker.new
+#broker.set_test_queue('tcp://*:5556', 'tcp://*:5557')
+#broker.set_confiq_queue('tcp://*:5540', 'tcp://*:5541')
+#broker.set_result_queue('tcp://*:5530', 'tcp://*:5531')
+#broker.start_broker
+
+#zmq = Kymera::SZMQ.new
+#
+#front_end = zmq.socket('tcp://*:5555', 'router')
+#back_end = zmq.socket('tcp://*:5556', 'dealer')
+#zmq.start_proxy(front_end, back_end)
+
+#context = ZMQ::Context.new
+#front_end = context.socket(ZMQ::ROUTER)
+#back_end = context.socket(ZMQ::DEALER)
+
+broker = Kymera::Broker.new('tcp://*:5550', 'tcp://127.0.0.1:5551', 'tcp://*:5552', 20)
+broker.start_broker
+
+
+

data/lib/spec/client_spec.rb

@@ -0,0 +1,21 @@
+require 'ffi-rzmq'
+require_relative '../../lib/kymera/v_4/kymera'
+#client = Kymera::Client.new('tcp://localhost:5556')
+#client.send_message("This is the message")
+zmq = SZMQ.new
+
+client = zmq.socket('tcp://127.0.0.1:5555', 'request')
+client.connect
+
+reply = client.send_message("This is a test")
+puts reply
+
+#context = ZMQ::Context.new
+#socket = context.socket(ZMQ::PUSH)
+#socket.bind('tcp://*:5555')
+#socket.send_string("This is a message")
+#reply = ''
+#unless socket.recv_string(reply) == -1
+#  socket.recv_string(reply)
+#  puts reply
+#end

data/lib/spec/client_test_run_spec.rb

@@ -0,0 +1,3 @@
+# require_relative '../../lib/kymera'
+require 'kymera'
+Kymera.run_tests('~/apollo/source/integration_tests/features/login_and_session/login.feature', 'cucumber', ['-p default'], 'develop', true)

data/lib/spec/config_options.txt

@@ -0,0 +1,51 @@
+This is a list of different config options for the kymera gem
+
+Client -
+    Broker address: ip address and port where the test broker is located
+    Results bus address: the ip address and port where the results bus is located
+
+Broker -
+    Client Listening Port: what port to listen to for incoming test run requests
+    Worker Listening Port: What port to listen to for incoming worker connections
+    Number of Connections: This parameter is used to set the number of threads the broker will spawn for running tests. It is important to note that this number
+                           needs to be larger than the number of connected workers. If not, the workers connected in excess of the number of threads will not be utilized
+                           There are plans to change this behavior in the future
+
+Worker -
+    Broker address: the ip address and port where the broker is located
+    Results Collector Address: the ip address and port where the results collector is located
+    Results Bus Address: the ip address and port where the results bus is located
+
+Results Collector -
+    Incoming Listening Port: The port number where results will be coming in
+    Results Bus Address: The ip address and port where the outgoing aggregated results will be sent
+    Use Mongo DB: This is a bool telling the collector whether or not to send the results to a mongodb instance
+    MongoDB Address: The ip address and port number where the completed results will be sent for archiving
+    MongoDB Name: The name of the database that test collector will send the results to
+    MongoDB Collection Name: The name of the collection that the results will belong to
+
+Results Bus -
+    Publish Port: The port which will be used for publishers to publish messages to the bus
+    Subscription Port: The port which will be used for subscribers to subscribe to
+
+
+Passable arguments for each component of Kymera
+
+Client -
+    real_time          : This parameter is used to tell the client whether or not to display the realtime output from all of the test workers
+    tests              : The file or director that contains the tests that need to be run
+    test_runner        : This is the runner that Kymera will used to run the tests. Currently only Cucumber is supported. There are plans to extend that later
+    test_runner_options: These are the options specific to the test runner.
+    branch             : This is the branch that the Kymera Workers should pull from to get the code that the user wishes to execute or test against
+
+Broker -
+    none
+
+Worker -
+    none
+
+Results Collector -
+    none
+
+Results Bus -
+    none

data/lib/spec/full_run_for_linux_spec.rb

@@ -0,0 +1,44 @@
+require 'kymera'
+threads = []
+
+trap('INT') do
+  threads.each do |thread|
+    thread.kill
+  end unless threads.empty?
+end
+
+#Results bus thread
+threads << Thread.new {
+  bus = Kymera::ResultsBus.new('tcp://*:7000', 'tcp://*:7001')
+  bus.start_bus
+}
+
+#Broker thread
+threads << Thread.new {
+  broker = Kymera::Broker.new('tcp://*:5550', 'tcp://127.0.0.1:5551', 'tcp://127.0.0.1:5552', 20)
+  broker.start_broker
+}
+
+#Results collector thread
+threads << Thread.new {
+  results_collector = Kymera::TestResultsCollector.new('tcp://*:5556', 'tcp://127.0.0.1:7000')
+  results_collector.listen
+}
+
+#Worker thread
+threads << Thread.new {
+  worker = Kymera::Worker.new('tcp://127.0.0.1:5552', 'tcp://127.0.0.1:5556', 'tcp://127.0.0.1:7000')
+  worker.listen
+}
+
+#give stuff a chance to start up
+sleep 2
+
+client = Kymera::Client.new('tcp://127.0.0.1:5550','tcp://127.0.0.1:7001')
+client.run_tests('~/apollo/source/integration_tests/features/login_and_session/logout.feature', 'cucumber', ['-p default'])
+#client.run_tests('c:/apollo/source/integration_tests/features', 'cucumber', ['-p dev'])
+
+
+
+
+

data/lib/spec/full_run_spec.rb

@@ -0,0 +1,44 @@
+require 'kymera'
+threads = []
+
+trap('INT') do
+  threads.each do |thread|
+    thread.kill
+  end unless threads.empty?
+end
+
+#Results bus thread
+threads << Thread.new {
+  bus = Kymera::ResultsBus.new('tcp://*:7000', 'tcp://*:7001')
+  bus.start_bus
+}
+
+#Broker thread
+threads << Thread.new {
+  broker = Kymera::Broker.new('tcp://*:5550', 'tcp://127.0.0.1:5551', 'tcp://127.0.0.1:5552', 20)
+  broker.start_broker
+}
+
+#Results collector thread
+threads << Thread.new {
+  results_collector = Kymera::TestResultsCollector.new('tcp://*:5556', 'tcp://127.0.0.1:7000')
+  results_collector.listen
+}
+
+#Worker thread
+threads << Thread.new {
+  worker = Kymera::Worker.new('tcp://127.0.0.1:5552', 'tcp://127.0.0.1:5556', 'tcp://127.0.0.1:7000')
+  worker.listen
+}
+
+#give stuff a chance to start up
+sleep 2
+
+client = Kymera::Client.new('tcp://127.0.0.1:5550','tcp://127.0.0.1:7001')
+client.run_tests('c:/apollo/source/integration_tests/features/login_and_session/logout.feature', 'cucumber', ['-p default'])
+client.run_tests('c:/apollo/source/integration_tests/features', 'cucumber', ['-p dev'])
+
+
+
+
+

data/lib/spec/get_bus_data.rb

@@ -0,0 +1,43 @@
+require_relative '../../lib/kymera'
+
+zmq = Kymera::SZMQ.new
+sub_socket = zmq.socket('tcp://127.0.0.1:7001', 'sub')
+
+#sub_socket2 = zmq.socket('tcp://127.0.0.1:7001', 'sub')
+
+  sub_socket.subscribe('results') do |channel, message|
+    $stdout << "."
+    puts channel
+    puts message
+  end
+#Thread.new {
+#  sub_socket2.subscribe('BVTCQD0CZ11') do |channel, message|
+#    $stdout << "."
+#  end
+#}
+#
+#
+#sub_socket.subscribe('end_BVTCQD0CZ11') do |channel, message|
+#  puts channel
+#  puts message
+#end
+
+
+#context = ZMQ::Context.new
+#socket = context.socket(ZMQ::SUB)
+#socket.setsockopt(ZMQ::SUBSCRIBE, 'end_BVTCQD0CZ11')
+#socket.connect('tcp://127.0.0.1:7001')
+#
+#socket_2 = context.socket(ZMQ::SUB)
+#socket_2.setsockopt(ZMQ::SUBSCRIBE, 'BVTCQD0CZ11')
+#socket_2.connect('tcp://127.0.0.1:7001')
+#
+#channel = ''
+#message = ''
+#
+#loop do
+#  socket.recv_string(channel)
+#  socket.recv_string(message)
+#  puts channel
+#  puts message
+#end

data/lib/spec/html_parser_spec.rb

@@ -0,0 +1,61 @@
+
+# require 'kymera'
+require_relative '../../lib/kymera/cucumber/cucumber_html_parser'
+
+results =  "Using the default profile...
+[36m@smoke_prod
+Feature: Login
+
+As a user
+I want to login
+So that I can do freight matching
+
+# JS - no longer valid
+#  Scenario: e. the footer is present on the login page
+#    Given I am at the login page
+#    Then I see the Terms and Conditions link
+#    And I see the Privacy link
+#    And I see the DAT copyright string
+Scenario: f. the footer is present on the welcome page       # c:\apollo\source\integration_tests\features\login_and_session\login.feature:39
+[32mGiven I am logged in                                       # features/step_definitions/login/login_steps.rb:5
+[32mThen I see the home page has the Terms and Conditions link # features/step_definitions/login/login_steps.rb:109
+[32mAnd I see the home page has the Privacy link               # features/step_definitions/login/login_steps.rb:113
+[32mAnd I see the home page has the DAT copyright string       # features/step_definitions/login/login_steps.rb:117
+
+1 scenario (1 passed)
+4 steps (4 passed)
+0m14.218s
+Using the default profile...
+[36m@smoke_prod
+Feature: Login
+
+As a user
+I want to login
+So that I can do freight matching
+
+Scenario: d. invalid username, valid password            # c:\apollo\source\integration_tests\features\login_and_session\login.feature:28
+[32mGiven I login with invalid username and valid password # features/step_definitions/login/login_steps.rb:14
+[32mThen I see an invalid login message                    # features/step_definitions/login/login_steps.rb:78
+
+1 scenario (1 passed)
+2 steps (2 passed)
+0m22.000s
+Using the default profile...
+[36m@smoke_prod
+Feature: Login
+
+As a user
+I want to login
+So that I can do freight matching
+
+Scenario: c. valid username, invalid password            # c:\apollo\source\integration_tests\features\login_and_session\login.feature:23
+[32mGiven I login with valid username and invalid password # features/step_definitions/login/login_steps.rb:9
+[32mThen I see an invalid login message                    # features/step_definitions/login/login_steps.rb:78
+
+1 scenario (1 passed)
+2 steps (2 passed)
+0m23.261s"
+
+
+parsed_results = Kymera::Cucumber::HTMLResultsParser.to_html(results)
+puts parsed_results

data/lib/spec/html_parsing_alg.txt

@@ -0,0 +1,31 @@
+1. take the results and parse them into an array with new line (\n) as the delimiter
+2. iterate over the array
+3. if line starts with "Using"
+    3a. create a string variable with an open div hmtl tag with the class feature
+    3b. append a open paragraph html tag to that variable
+    3c. append the line to the variable
+
+4. until line starts with "Using"
+    4a. move to the next line
+    4b. if the line contains \e
+        4c. iterate over the line and for every \e do the following
+            4d. if the next 3 characters match 36m
+                4e. append an open span tag to the string variable with the style color blue
+            4f. if the next 3 characters match 90m
+                4g.append an open span tag to the string variable with the style color gray
+            4h. if the next 3 characters match 31m
+                    4i. append an open span tag to the string variable with the style color red
+            4j  if the next 3 characters match 0m
+                    4k. append a closing span tag to the string variable and start again at step 4a
+            4l. if there are no other instances of \e
+                    4m. append the remainder of the line and a close span tag to the string variable
+            4n. if there are more instances of \e
+                    4o. until you reach the next instance of \e
+                        4p. continue iterating over the line, appending each character to the sting variable
+                    4q. when you reach the next instance of \e start again at step 4d
+
+                    add check for characters after 0m
+
+
+
+

data/lib/spec/json_message_example.txt

@@ -0,0 +1,6 @@
+{   "run_id" : "1",
+    "test" : "./feature/login_and_session/login.feature",
+    "runner" : "cucumber",
+    "options" : ["-p default"]
+    }
+    

data/lib/spec/mongo_driver_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../../lib/kymera'
+
+message = JSON.generate({name: "test"})
+
+Kymera::MongoDriver.log_results(message)

data/lib/spec/plain_broker_spec.rb

@@ -0,0 +1,44 @@
+require 'ffi-rzmq'
+
+context = ZMQ::Context.new
+front_end_socket = context.socket(ZMQ::ROUTER)
+front_end_socket.bind('tcp://*:5550')
+
+back_end_socket = context.socket(ZMQ::DEALER)
+back_end_socket.bind('tcp://*:5551')
+
+ZMQ::Device.new(front_end_socket, back_end_socket)
+
+#require 'rubygems'
+#require 'ffi-rzmq'
+#
+#context = ZMQ::Context.new
+#frontend = context.socket(ZMQ::ROUTER)
+#backend = context.socket(ZMQ::DEALER)
+#
+#frontend.bind('tcp://*:5550')
+#backend.connect('tcp://127.0.0.1:5551')
+#
+#message = []
+#
+#frontend.recv_strings message
+#puts message
+#
+#backend.send_strings(message)
+
+#poller = ZMQ::Poller.new
+#poller.register(frontend, ZMQ::POLLIN)
+#poller.register(backend, ZMQ::POLLIN)
+#
+#loop do
+#  poller.poll(:blocking)
+#  poller.readables.each do |socket|
+#    if socket === frontend
+#      socket.recv_strings(messages = [])
+#      backend.send_strings(messages)
+#    elsif socket === backend
+#      socket.recv_strings(messages = [])
+#      frontend.send_strings(messages)
+#    end
+#  end
+#end

data/lib/spec/plain_reply_socket_spec.rb

@@ -0,0 +1,13 @@
+require 'ffi-rzmq'
+
+context = ZMQ::Context.new
+socket = context.socket(ZMQ::REP)
+socket.connect 'tcp://127.0.0.1:5551'
+
+message = ''
+
+socket.recv_string message
+
+puts message
+
+socket.send_string "Got the messsage"

data/lib/spec/plain_request_socket_spec.rb

@@ -0,0 +1,13 @@
+require 'ffi-rzmq'
+
+context = ZMQ::Context.new
+socket = context.socket(ZMQ::REQ)
+socket.connect('tcp://127.0.0.1:5550')
+
+socket.send_string "This is a message"
+
+reply = ''
+
+socket.recv_string reply
+
+puts reply

data/lib/spec/result_bus_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../lib/kymera'
+
+bus = Kymera::ResultsBus.new('tcp://*:7000', 'tcp://*:7001')
+bus.start_bus
+
+#context = ZMQ::Context.new
+#front_end_socket = context.socket(ZMQ::XSUB)
+#back_end_socket = context.socket(ZMQ::XPUB)
+#
+#front_end_socket.connect('tcp://127.0.0.1:7000')
+#back_end_socket.bind('tcp://*:7001')
+#
+#ZMQ::Device.new(front_end_socket, back_end_socket)

data/lib/spec/results_parser_test_run_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../../lib/kymera'
+#zmq = Kymera::SZMQ.new
+#
+#socket = zmq.socket('tcp://*:5556', 'pull')
+#socket.bind
+#socket.receive do |results|
+#  puts results
+#end
+
+#context = ZMQ::Context.new
+#socket = context.socket(ZMQ::PULL)
+#socket.bind('tcp://127.0.0.1:5555')
+#message = ''
+#socket.recv_string(message)
+#puts message
+
+results_parser = Kymera::TestResultsCollector.new('tcp://*:5556', 'tcp://127.0.0.1:7000')
+results_parser.listen

data/lib/spec/send_bus_data.rb

@@ -0,0 +1,16 @@
+require_relative '../../lib/kymera'
+
+zmq = Kymera::SZMQ.new
+#
+pub_socket = zmq.socket('tcp://127.0.0.1:7000', 'pub')
+pub_socket.connect
+pub_socket.publish_message('results', 'these are results')
+
+#context = ZMQ::Context.new
+#socket = context.socket(ZMQ::PUB)
+#socket.connect('tcp://127.0.0.1:7000')
+#sleep 5
+#socket.send_string('results', ZMQ::SNDMORE)
+#socket.send_string('these are some more results')
+
+

data/lib/spec/startup_broker_bus_collector_spec.rb

@@ -0,0 +1,35 @@
+require 'kymera'
+threads = []
+
+trap('INT') do
+  threads.each do |thread|
+    thread.kill
+  end unless threads.empty?
+  @close = true
+end
+
+#Results bus thread
+threads << Thread.new {
+  # bus = Kymera::ResultsBus.new('tcp://*:7000', 'tcp://*:7001')
+  # bus.start_bus
+  Kymera.start_bus
+}
+
+#Broker thread
+threads << Thread.new {
+  # broker = Kymera::Broker.new('tcp://*:5550', 'tcp://*:5551', 'tcp://*:5552', 20)
+  # broker.start_broker
+  Kymera.start_broker
+}
+
+#Results collector thread
+threads << Thread.new {
+  # results_collector = Kymera::TestResultsCollector.new('tcp://*:5556', 'tcp://127.0.0.1:7000')
+  # results_collector = Kymera::TestResultsCollector.new('tcp://*:5556', 'tcp://10.6.49.60:7000')
+  # results_collector.listen
+  Kymera.start_collector
+}
+
+loop do
+  raise SystemExit if @close
+end