theotokos 0.1.1

data/lib/config/app_logger.rb

@@ -0,0 +1,48 @@
+module Theotokos
+  module Configuration
+
+    class AppLogger
+    
+      @@appenders = []
+    
+      def self.add_stdout_logger
+        Logging.appenders.stdout(
+          :level => ENV['logger.stdout.level'].to_sym,
+          :layout => Logging::Layouts::Pattern.new(:date_pattern => ENV['logger.stdout.layout.date_pattern'], :pattern => ENV['logger.stdout.layout.pattern'])
+        )
+        
+        @@appenders << 'stdout' unless @@appenders.include? 'stdout'
+      end
+      
+      def self.add_rolling_file_logger
+        dir = File.dirname ENV['logger.rolling_file.file']
+        FileUtils.mkdir_p dir unless File.exist? dir
+        
+        file = ENV['logger.rolling_file.file'].dup
+        file << ".#{Time.now.strftime('%Y-%m-%d')}" unless ENV['logger.rolling_file.file.append_date'] == 'false'
+        
+        Logging.appenders.rolling_file(
+          file, :level => ENV['logger.rolling_file.level'].to_sym,
+          :layout => Logging::Layouts::Pattern.new(:date_pattern => ENV['logger.rolling_file.date_pattern'],
+          :pattern => ENV['logger.rolling_file.pattern'])
+        )
+        
+        @@appenders << file unless @@appenders.include? file
+      end
+      
+      def self.create_logger(source = nil)
+        if @@appenders.empty?
+          puts 'WARNING! There is no appender specified.'
+          return nil
+        end
+        
+        logger = Logging.logger[source ||= self]
+        logger.add_appenders @@appenders
+        
+        return logger
+      end
+    
+    end
+
+  end
+end

data/lib/engine/execution_initializer.rb

@@ -0,0 +1,115 @@
+module Theotokos
+  module Engine
+
+    class ExecutionInitializer
+    
+      def initialize
+        yield self if block_given?
+      end
+      
+      def init_executors
+        raise Exception, 'Execution command params must not be empty.' unless @command
+        puts "\n >>> Tags: #{@command.tags.join(', ')}\n\n" unless (@command.tags.nil? || @command.tags.empty?)
+        suites = []
+        console_report = Reporter.create_reporter(:console) if @command.report_formats.include? :console
+        
+        ExecutionInitializer._before_app
+        Helper.load_support_files
+        
+        @command.test_files.each do |file|
+          model = nil
+          begin
+            model = Parser.yaml_to_test_suite file
+          rescue Exception => ex
+            suites << ExecutionInitializer.error_test_suite_result(ex, file)
+            puts "WARN: Error parsing model '#{file}': #{ex}"
+            next
+          end
+
+          model.source = file
+
+          suite = SoapExecutor.new do |exe|
+            exe.test_suite = model
+            exe.test_index = @command.test_index
+            exe.ws_config = @ws_config
+            exe.tags_input = @command.tags
+            exe.console_report = console_report
+          end.execute
+          
+          next if suite.nil?
+          
+          suite.calculate_totals
+          console_report.print suite unless console_report.nil?
+          suites << suite
+          puts
+        end
+        
+        @test_app_result = TestAppResult.new do |t|
+          t.suites = suites
+          t.calculate_totals
+        end
+        
+        ExecutionInitializer._after_app @test_app_result
+        console_report.print @test_app_result unless console_report.nil?
+      end
+    
+      def self.load_test_models(path)
+        ((path.nil?) ? ExecutionInitializer.load_all_test_models : ExecutionInitializer.load_test_models_by_path(path))
+      end
+      
+      def self.load_test_models_by_path(model_path)
+        path = model_path.dup
+
+        unless path.end_with? '.yml'
+          path << '/' unless path.end_with? '/'
+          path << '**/*.yml'
+        end
+        
+        Dir.glob(path).map {|file| file }
+      end
+      
+      def self.load_all_test_models
+        ExecutionInitializer.load_test_models_by_path ENV['ws.test.models.path']
+      end
+      
+      def self.error_test_suite_result(ex, file)
+        TestSuiteResult.new do |r|
+          r.model = TestSuite.new do |s|
+            s.source = file
+            s.wsdl = '???'
+            s.service = '???'
+          end
+          
+          r.test_results = [
+            TestResult.new do |test|
+              test.name = '1'
+              test.status = TestStatus.new :test_file_status => false, :test_text_status => { :error => true }
+              test.error = { :message => ex.to_s, :backtrace => ex.backtrace }
+            end
+          ]
+        end
+      end
+      
+      def self._before_app
+        return if HOOKS[:before_app].nil?
+        
+        HOOKS[:before_app].each do |block|
+          block.call
+        end
+      end
+      
+      def self._after_app(result)
+        return if HOOKS[:after_app].nil?
+        
+        HOOKS[:after_app].each do |block|
+          block.call result
+        end
+      end
+            
+      attr_accessor :command, :ws_config
+      attr_reader :test_app_result
+    
+    end
+
+  end
+end

data/lib/engine/executor.rb

@@ -0,0 +1,128 @@
+module Theotokos
+  module Engine
+
+    class Executor
+      
+      attr_accessor :test_suite, :test_index, :ws_config, :tags_input, :console_report
+      
+      protected
+      def save_web_service_result(data)
+        Dir.mkdir 'tmp' unless File.exist? 'tmp'
+        file_name = "tmp/#{@test_suite.name}_#{@count}.xml"
+        @logger.info "Web service response saved to #{file_name}"
+      
+        File.open(file_name, 'w') {|file| file.write data }
+        file_name
+      end
+      
+      def should_execute?
+        return true if @tags_input.nil?
+        
+        @tags_input.each do |tag|
+          return true if @test_suite.has_tag? tag
+        end
+        
+        false
+      end
+      
+      def should_execute_test?(test)
+        return true if @tags_input.nil?
+        
+        @tags_input.each do |tag|
+          return true if test.has_tag? tag
+        end
+        
+        false
+      end
+      
+      def validate_test_execution(expected_output, outcoming_file)
+        return TestStatus.new :error => false if expected_output.nil?
+        
+        begin
+          res = {}
+          
+          if expected_output['file']
+            file = if expected_output['file'].start_with?(ENV['ws.test.output.files.path'])
+               expected_output['file']
+            else
+              "#{ENV['ws.test.output.files.path']}/#{expected_output['file']}"
+            end
+            res[:file] = TestAssertion.compare_file file, outcoming_file
+          end
+          
+          if expected_output['text']
+            res[:text] = {}
+            assertions = _get_assertions expected_output['text']
+            
+            assertions.each do |assertion|
+              res[:text][assertion] = TestAssertion.compare_text expected_output['text'][assertion.to_s], File.read(outcoming_file), assertion
+            end
+          end
+          
+          return TestStatus.new :test_file_status => res[:file], :test_text_status => res[:text]
+        rescue Exception => ex
+          stack = ex.backtrace.join "\n"
+          @logger.warn "Test validation has failed for test ##{@count}: #{ex.to_s}\n#{stack}"
+          
+          return ex
+        end
+      end
+      
+      def before_suite(test_suite)
+        @logger.debug 'Playing Before Suite'
+        return if HOOKS[:before_suite].nil?
+        
+        HOOKS[:before_suite].each do |block|
+          block.call test_suite
+        end
+      end
+      
+      def after_suite(test_suite, test_suite_result)
+        @logger.debug 'Playing After Suite'
+        return if HOOKS[:after_suite].nil?
+        
+        test_suite_result.calculate_totals
+        HOOKS[:after_suite].each do |block|
+          block.call test_suite, test_suite_result
+        end
+      end
+      
+      def before_test(test)
+        @logger.debug 'Playing Before Test'
+        return if HOOKS[:before_test].nil?
+        
+        HOOKS[:before_test].each do |block|
+          block.call test
+        end
+      end
+      
+      def after_test(test, test_result)
+        @logger.debug 'Playing After Test'
+        return if HOOKS[:after_test].nil?
+        
+        HOOKS[:after_test].each do |block|
+          block.call test, test_result
+        end
+      end
+      
+      private
+      def _get_assertions(hash)
+        assertions = []
+        ['equals', 'contains', 'not_contains', 'regex'].each do |assertion|
+          next if hash[assertion].nil?
+          
+          assertions << case assertion
+            when 'equals' then :equals
+            when 'contains' then :contains
+            when 'not_contains' then :not_contains
+            when 'regex' then :regex
+          end
+        end
+        
+        assertions
+      end
+    
+    end
+
+  end
+end

data/lib/engine/parser.rb

@@ -0,0 +1,39 @@
+module Theotokos
+  module Engine
+
+    class Parser
+    
+      def self.yaml_to_test_suite(source)
+        Parser.hash_to_test_suite Parser.yaml_to_hash(source)
+      end
+    
+      def self.yaml_to_hash(source)
+        raise Exception, "File #{source} does not exist." unless File.exist? source
+        YAML.load_file source
+      end
+      
+      def self.hash_to_test_suite(hash)
+        Model::TestSuite.new do |suite|
+          suite.wsdl = hash['wsdl']
+          suite.service = hash['service']
+          suite.description = hash['description']
+          suite.tags = hash['tags']
+          
+          suite.tests = hash['tests'].map do |te|
+            Model::Test.new do |t|
+              t.name = te['name']
+              t.description = te['description']
+              t.input = te['input']
+              t.output = te['output']
+              t.tags = te['tags']
+              t.ws_security = te['ws-security']
+              t.error_expected = te['error_expected']
+            end
+          end unless hash['tests'].nil?
+        end
+      end
+    
+    end
+
+  end
+end

data/lib/engine/soap_executor.rb

@@ -0,0 +1,101 @@
+module Theotokos
+  module Engine
+
+    class SoapExecutor < Executor
+    
+      def initialize
+        @count = 0
+        @logger = AppLogger.create_logger self
+        yield self if block_given?
+      end
+      
+      def execute
+        return unless self.should_execute?
+        @logger.info "Execute Soap Test '#{@test_suite.source}'"
+        @logger.info "WSDL: #{@test_suite.wsdl}"
+        @logger.info "Service: #{@test_suite.service}"
+        
+        self.before_suite @test_suite
+        test_suite_result = _execute_test_suite      
+        self.after_suite @test_suite, test_suite_result
+        
+        test_suite_result
+      end
+      
+      private
+      def _execute_test_suite
+        res = TestSuiteResult.new do |r|
+          r.model = @test_suite
+          r.test_results = _execute
+        end
+        
+        res
+      end
+      
+      def _execute
+        results = []
+        @test_suite.tests.each do |test|
+          @count += 1
+          next if !@test_index.nil? && @test_index != @count
+          next unless self.should_execute_test? test
+          
+          result = {}
+          self.before_test test
+          test_result = TestResult.new do |t|
+            t.name = ((test.name.nil?) ? @count : test.name)
+            t.description = test.description
+            t.error_expected = test.error_expected
+            t.tags = test.tags
+            t.skip = test.skip
+          end
+          
+          test_result.test_expectation = test.output
+          if test.skip
+            @logger.warn "Skiping test '#{test.name}'"
+            results << test_result
+            next
+          end
+            
+          res = SoapNet.send_request :wsdl => @test_suite.wsdl, :ws_config => @ws_config,
+            :ws_security => test.ws_security, :service => @test_suite.service, :params => test.input
+          
+          if res[:success] == false && !test_result.error_expected
+            test_result.error = { :message => 'Send request failure', :backtrace => res[:xml] }
+            test_result.status = TestStatus.new :error => true
+            results << test_result
+            
+            @console_report.print test_result unless @console_report.nil?
+            self.after_test test, test_result
+            next
+          elsif res[:success] == true && test_result.error_expected
+            test_result.error = { :message => 'It was supposed to get an exception but nothing was caught.' }
+            test_result.status = TestStatus.new :error => true
+            results << test_result
+            
+            @console_report.print test_result unless @console_report.nil?
+            self.after_test test, test_result
+            next
+          end
+          
+          test_result.test_actual = save_web_service_result res[:xml]
+          test_res = validate_test_execution test.output, test_result.test_actual
+
+          if test_res.instance_of? Theotokos::Model::TestStatus
+            test_result.status = test_res
+          else
+            test_result.error = { :message => test_res.to_s, :backtrace => test_res.backtrace }
+            test_result.status = TestStatus.new :error => true
+          end
+          
+          results << test_result
+          @console_report.print test_result unless @console_report.nil?
+          self.after_test test, test_result
+        end
+        
+        results
+      end
+    
+    end
+
+  end
+end

data/lib/helper/app_helper.rb

@@ -0,0 +1,99 @@
+module Theotokos
+  module Helper
+
+    def parse_cmd_options
+      command = Execution.new
+      
+      opts = OptionParser.new do |opts|
+        opts.banner = "Theotokos: a tool for web service testing"
+        opts.define_head "Usage: theotokos [path:test_index] [options]"
+        opts.separator ""
+        opts.separator "Examples:"
+        opts.separator " theotokos"
+        opts.separator " theotokos resources/ws-test-model/project_xpto"
+        opts.separator " theotokos resources/ws-test-model/project_xpto/web_service_test.yml"
+        opts.separator " theotokos resources/ws-test-model/project_xpto/web_service_test.yml:1"
+        opts.separator " theotokos -r console html json -t foo"
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on('-t', "--tags t1,t2,t3", Array, 'Specify test tags') do |tags|
+          command.tags = tags
+        end
+
+        opts.on("-r", "--report-formats r1,r2,r3", Array, "Output test report formats. Must be one of [console, html, json]") do |formats|
+          params = []
+          formats.each do |f|
+            raise "Supported report formats are: [console, html, json]. Found '#{f}' in [#{formats.join(', ')}]" unless ['console', 'html', 'json'].include? f
+            params << f.to_sym
+          end
+          command.report_formats = params
+        end
+        
+        opts.on("-i", "--internationalization [OPT]", String, "Sets custom locale. Example: en, pt etc.") do |internationalization|
+          command.internationalization = internationalization
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Show version") do
+          puts "theotokos #{Theotokos::VERSION}"
+          exit
+        end
+      end
+      
+      begin
+        opts.parse!
+        test_models_path = ARGV.pop
+        match = /.yml:(\d+)$/.match(test_models_path)
+        
+        command.test_index = match.captures.first.to_i unless match.nil?      
+        command.execution_path = test_models_path.sub(/:(\d+)$/, '') if test_models_path
+        
+        command
+      rescue Exception => ex      
+        puts " - Error: #{ex}" unless ex.instance_of? SystemExit
+        exit -1
+      end
+    end
+
+    def diff_time(inicio, fim)
+      diferenca = (fim - inicio)
+      s = (diferenca % 60).to_i
+      m = (diferenca / 60).to_i
+      h = (m / 60).to_i
+
+      if s > 0
+        "#{(h < 10) ? '0' + h.to_s : h}:#{(m < 10) ? '0' + m.to_s : m}:#{(s < 10) ? '0' + s.to_s : s}"
+      else
+        format("%.5f", diferenca) + " s."
+      end
+    end
+    
+    class << self
+      def format_ws_model_path(file)
+        format_app_path 'ws.test.models.path', file
+      end
+      
+      def format_ws_output_path(file)
+        format_app_path 'ws.test.output.files.path', file
+      end
+      
+      def format_app_path(key, file)
+        f = file.sub Regexp.new("^#{ENV[key]}"), ''
+        File.join(ENV[key], f)
+      end
+      
+      def load_support_files
+        Dir.glob(File.join(Dir.pwd, "support", "**", "*.rb"))
+          .sort_by {|file| file.scan(File::SEPARATOR).size }
+          .each {|file| require file }
+      end
+      
+    end
+
+  end
+end

data/lib/helper/hook_helper.rb

@@ -0,0 +1,49 @@
+HOOKS = {}
+
+def before_app(&block)
+  if HOOKS[:before_app].nil?
+    HOOKS[:before_app] = [block]
+  else
+    HOOKS[:before_app] << block
+  end
+end
+
+def after_app(&block)
+  if HOOKS[:after_app].nil?
+    HOOKS[:after_app] = [block]
+  else
+    HOOKS[:after_app] << block
+  end
+end
+
+def before_suite(&block)
+  if HOOKS[:before_suite].nil?
+    HOOKS[:before_suite] = [block]
+  else
+    HOOKS[:before_suite] << block
+  end
+end
+
+def after_suite(&block)
+  if HOOKS[:after_suite].nil?
+    HOOKS[:after_suite] = [block]
+  else
+    HOOKS[:after_suite] << block
+  end
+end
+
+def before_test(&block)
+  if HOOKS[:before_test].nil?
+    HOOKS[:before_test] = [block]
+  else
+    HOOKS[:before_test] << block
+  end
+end
+
+def after_test(&block)
+  if HOOKS[:after_test].nil?
+    HOOKS[:after_test] = [block]
+  else
+    HOOKS[:after_test] << block
+  end
+end