theotokos 0.1.1

data/lib/model/test.rb

@@ -0,0 +1,79 @@
+module Theotokos
+  module Model
+        
+    class Test
+    
+      def initialize
+        @error_expected = @skip = false
+        yield self if block_given?
+        
+        @tags ||= []
+        @input ||= {}
+        @output ||= {}
+        @ws_security ||= {}
+        
+        _config_tags @tags
+        _validation
+      end
+    
+      attr_accessor :name, :description, :tags, :input, :output, :ws_security, :error_expected, :error, :skip
+      
+      def to_hash
+        { :name => @name, :description => @description, :error_expected => @error_expected,
+          :tags => @tags, :input => @input, :output => @output, :ws_security => @ws_security, :skip => @skip }
+      end
+      
+      def has_tag?(tag)
+        @tags.each {|t| return true if tag == t }
+        false
+      end
+      
+      private
+      def _config_tags(t)
+        self.tags = if t.instance_of? String
+          t.split(/[,\s]/).select {|t| !t.empty? }
+        elsif t.instance_of? Array
+          t
+        else
+          []
+        end
+      end
+      
+      def _validation
+        _validate_input
+        _validate_output
+        _validate_ws_security
+      end
+      
+      def _validate_input
+        raise 'Input of test model must be a Hash' unless @input.instance_of? Hash
+      end
+      
+      def _validate_output
+        raise 'Output of test model must be a Hash' unless @output.instance_of? Hash
+        if @output['file']
+          raise "test > output > file >> '#{@output['file']}' does not exist" unless File.exist? Helper.format_ws_output_path(@output['file'])
+        end
+        
+        if @output['text']
+          raise 'test > output > text must be a Hash' unless @output['text'].instance_of? Hash
+          hash = @output['text']
+          unless (hash.has_key?('equals') || hash.has_key?('contains') || hash.has_key?('not_contains') || hash.has_key?('regex'))
+            raise 'test > output > text must have one o those keys [equals, contains, not_contains, regex]'
+          end
+        end
+      end
+      
+      def _validate_ws_security
+        raise 'Ws-security of test model must be a Hash' unless @ws_security.instance_of? Hash
+        unless @ws_security.keys.empty?
+          unless (@ws_security.has_key?('login') && @ws_security.has_key?('password'))
+            raise 'test > output > ws-security must have configured login and password keys'
+          end
+        end
+      end
+    
+    end
+    
+  end
+end

data/lib/model/test_app_result.rb

@@ -0,0 +1,91 @@
+module Theotokos
+  module Model
+
+    class TestAppResult
+    
+      def initialize
+        @success = false
+        @broken_suites = []
+        yield self if block_given?
+      end
+      
+      attr_accessor :suites, :date_report
+      attr_reader :total_failures, :total_success, :broken_suites
+      
+      def calculate_totals
+        @total_failures = @total_success = 0
+        @broken_suites.clear
+        return if @suites.nil?
+        
+        @suites.each do |suite|
+          suite.calculate_totals
+          if suite.error?
+            @total_failures += 1
+            @broken_suites << suite
+          end
+          @total_success += 1 if suite.success?
+        end
+        
+        @success = @total_failures == 0
+      end
+      
+      def success?
+        @success
+      end
+      
+      def error?
+        !success?
+      end
+      
+      def total_suites
+        (@suites.nil?) ? 0 : @suites.size
+      end
+      
+      def total_test_cases
+        return 0 if @suites.nil?
+        
+        total = 0
+        @suites.each {|suite| total += suite.test_results.size }
+        total
+      end
+      
+      def success_failures_stats
+        {
+          :success => { :total => @total_success, :stat => ((@total_success * 100 / @suites.size).to_f.round 2) },
+          :failures => { :total => @total_failures, :stat => ((@total_failures * 100 / @suites.size).to_f.round 2) }
+        }
+      end
+      
+      def tags_stats
+        tags = {}
+        @suites.each do |suite|
+          suite.test_results.each do |test|
+            test_tags = suite.model.tags | test.tags
+            if test_tags.empty?
+              tags[:none] = tags[:none].to_i + 1
+              next
+            end
+            
+            test_tags.each {|tag| tags[tag.to_sym] = tags[tag.to_sym].to_i + 1 }
+          end
+        end
+        
+        total = self.total_test_cases.to_f
+        tags.each do |k, v|
+          stat = (v * 100 / total).to_f.round 2
+          tags[k] = { :total => v, :stat => stat }
+        end
+        
+        tags
+      end
+      
+      def to_hash
+        { :total_failures => @total_failures, :total_success => @total_success, :date_report => @date_report,
+          :broken_suites => ((@broken_suites) ? @broken_suites.map {|s| s.to_hash } : @broken_suites),
+          :suites => ((@suites) ? @suites.map {|s| s.to_hash } : @suites) }
+      end
+      
+     end
+      
+  end
+end

data/lib/model/test_result.rb

@@ -0,0 +1,22 @@
+module Theotokos
+  module Model
+
+    class TestResult
+    
+      def initialize
+        @error_expected = skip = false
+        yield self if block_given?
+      end
+      
+      attr_accessor :name, :description, :tags, :status, :error, :test_expectation, :test_actual, :error_expected, :filter, :skip
+    
+      def to_hash
+        { :name => @name, :description => @description, :tags => @tags, :status => ((@status) ? @status.to_hash : @status),
+          :error => @error, :test_expectation => @test_expectation, :test_actual => @test_actual,
+          :error_expected => @error_expected, :filter => ((@filter) ? @filter.to_hash : @filter), :skip => @skip }
+      end
+      
+    end
+
+  end
+end

data/lib/model/test_status.rb

@@ -0,0 +1,68 @@
+module Theotokos
+  module Model
+
+    class TestStatus
+    
+      def initialize(opt = {})
+        if block_given?
+          yield self
+        else
+          _load_properties opt
+        end
+      end
+      
+      attr_accessor :test_file_status, :test_text_status
+      attr_writer :error
+      
+      def success?
+        return !@error unless @error.nil?
+        
+        if (@test_file_status.nil? && @test_text_status.nil?)
+          nil
+        elsif (@test_file_status == true)
+          (@test_text_status.nil? || _validate_test_text_status == true)
+        elsif (_validate_test_text_status == true)
+          (@test_file_status == true || @test_file_status.nil?)
+        else
+          false
+        end
+      end
+      
+      def error?
+        return @error unless @error.nil?      
+        
+        ok = success?
+        ok.nil? ? nil : !ok
+      end
+      
+      def to_s
+        "Model::TestStatus @error: #{@error}, @test_file_status: #{@test_file_status}, @test_text_status: #{@test_text_status}"
+      end
+      
+      def to_hash
+        { :test_file_status => @test_file_status, :test_text_status => @test_text_status,
+          :error => @error }
+      end
+      
+      private
+      def _load_properties(opt)
+        @test_file_status = opt[:test_file_status]
+        @test_text_status = opt[:test_text_status]
+        @error = opt[:error]
+      end
+      
+      def _validate_test_text_status
+        ok = false
+        return ok if @test_text_status.nil?
+        
+        @test_text_status.each_value do |v|
+          ok = v
+          break if ok == false
+        end
+        ok
+      end
+    
+    end
+
+  end
+end

data/lib/model/test_suite.rb

@@ -0,0 +1,80 @@
+module Theotokos
+  module Model
+        
+    class TestSuite
+    
+      def initialize(opt = {})
+        if block_given?
+          yield self
+          _config_tags @tags
+        else
+          _load_properties opt
+        end
+        @tests ||= Array.new      
+      end
+      
+      attr_accessor :source, :wsdl, :service, :description, :tags, :tests
+      
+      def validate_model!
+        raise Exception, 'WS test model must be provided.' if @source.nil? || @source.empty?
+        raise Exception, "WSDL's URL must be provided." if @wsdl.nil? || @wsdl.empty?
+        raise Exception, 'Service name (service to be tested) must be provided.' if @service.nil? || @service.empty?
+      end
+      
+      def has_tag?(tag)
+        (@tags + @tests.map {|t| t.tags }.flatten).each {|t| return true if t == tag }
+        false
+      end
+      
+      def name
+        regex = Regexp.new ENV['ws.test.models.path'].sub(/\/$/, '')
+        name =@source.sub regex, ''
+        name.sub! /^\//, ''
+        
+        name.sub('.yml', '').split('/').join('_')
+      end
+      
+      def to_hash
+        { :source => @source, :wsdl => @wsdl, :service => @service, :descriptio => @description,
+          :tags => @tags, :tests => ((@tests) ? @tests.map {|t| t.to_hash } : @tests) }
+      end
+      
+      private
+      def _load_properties(opt)
+        self.source = opt[:source]
+        self.wsdl = opt[:wsdl]
+        self.service = opt[:service]
+        self.description = opt[:description]
+        
+        _config_tags opt[:tags]
+        @tests = _load_tests opt[:tests]
+      end
+      
+      def _config_tags(t)
+        self.tags = if t.instance_of? String
+          t.split(/[,\s]/).select {|t| !t.empty? }
+        elsif t.instance_of? Array
+          t
+        else
+          []
+        end
+      end
+      
+      def _load_tests(array)
+        array ||= []
+        data = []
+        array.each do |test|
+          data << Test.new do |t|
+            t.input = test['input']
+            t.output = test['output']
+            t.ws_security = test['ws-security']
+          end
+        end
+        
+        data
+      end
+    
+    end
+    
+  end
+end

data/lib/model/test_suite_result.rb

@@ -0,0 +1,54 @@
+module Theotokos
+  module Model
+
+    class TestSuiteResult
+    
+      def initialize
+        @success = false
+        @broken_tests = []
+        yield self if block_given?
+      end
+      
+      attr_accessor :model, :test_results
+      attr_reader :total_failures, :total_success, :broken_tests
+    
+      def calculate_totals
+        @total_failures = @total_success = 0
+        @broken_tests.clear
+        return if @test_results.nil?
+        
+        @test_results.each do |res|
+          next if res.status.nil?
+          if res.status.error?
+            @total_failures += 1
+            @broken_tests << res
+          end
+          @total_success += 1 if res.status.success?
+        end
+        
+        @success = @total_failures == 0
+      end
+      
+      def success?
+        @success
+      end
+      
+      def error?
+        !success?
+      end
+      
+      def total_tests
+        (@test_results.nil?) ? 0 : @test_results.size
+      end
+      
+      def to_hash
+        { :model => ((@model) ? @model.to_hash : @model),
+        :test_results => ((@test_results) ? @test_results.map {|t| t.to_hash } : @test_results),
+        :total_failures => @total_failures, :total_success => @total_success,
+        :broken_tests => @broken_tests }
+      end
+      
+    end
+
+  end
+end

data/lib/model/text_operator.rb

@@ -0,0 +1,34 @@
+module Theotokos
+  module Model
+
+    class TextOperator
+    
+      def initialize(opt = {})
+        if block_given?
+          yield self
+        else
+          _load_properties opt
+        end
+      end
+      
+      attr_accessor :contains, :not_contains, :equals, :regex
+      
+      def to_hash
+        Hash.new({
+          :contains => @contains, :not_contains => @not_contains,
+          :equals => @equals, :regex => @regex
+        })
+      end
+      
+      private
+      def _load_properties(opt)
+        @contains = opt[:contains]
+        @not_contains = opt[:not_contains]
+        @equals = opt[:equals]
+        @regex = opt[:regex]
+      end
+    
+    end
+
+  end
+end

data/lib/model/ws_config.rb

@@ -0,0 +1,48 @@
+module Theotokos
+  module Model
+
+    class WsConfig
+    
+      def initialize
+        yield self if block_given?
+      end
+      
+      attr_accessor :env_namespace, :namespaces, :ssl_verify_mode, :ssl_version,
+                    :ssl_cert_file, :ssl_cert_key_file, :ssl_ca_cert_file, :ssl_cert_key_password
+
+      def self.ws_attributes
+        %W(env_namespace namespaces ssl_verify_mode ssl_version ssl_cert_file ssl_cert_key_file
+            ssl_ca_cert_file ssl_cert_key_password)
+      end
+        
+      def self.load_ws_config
+        return WsConfig.new unless File.exist? ENV['ws.config.path']
+        
+        data = YAML.load_file ENV['ws.config.path']
+        profile = ((ENV['profile'] == 'default' || ENV['profile'].nil?) ? '' : "#{ENV['profile']}.")
+
+        WsConfig.new do |c|
+          c.env_namespace = data['request.env.namespace']
+          
+          if data['request.namespaces']
+            namespaces = {}
+            data['request.namespaces'].to_s.split(',').each do |namespace|
+              tokens = namespace.split '='
+              namespaces[tokens[0].strip] = tokens[1].strip
+            end
+            c.namespaces = namespaces
+          end
+          
+          c.ssl_verify_mode = data["#{profile}ssl.verify.mode"].to_sym if data["#{profile}ssl.verify.mode"]
+          c.ssl_version = data["#{profile}ssl.version"].to_sym if data["#{profile}ssl.version"]
+          c.ssl_cert_file = data["#{profile}ssl.cert.file"]
+          c.ssl_cert_key_file = data["#{profile}ssl.cert.key.file"]
+          c.ssl_ca_cert_file = data["#{profile}ssl.ca.cert.file"]
+          c.ssl_cert_key_password = data["#{profile}ssl.cert.key.password"]
+        end
+      end
+    
+    end
+
+  end
+end

data/lib/net/soap_net.rb

@@ -0,0 +1,58 @@
+module Net
+
+  class SoapNet
+  
+    def self.send_request(options)
+      logger = AppLogger.create_logger self
+      client = _savon_client options[:wsdl], options[:ws_config], options[:ws_security]
+      service = options[:service].to_s.gsub(/(.)([A-Z])/,'\1_\2').downcase # snake_case
+      xml = success = nil
+      
+      begin
+        logger.debug "Send request to service '#{service}'"
+        response = client.call service.to_sym, :message => options[:params]
+        xml = Nokogiri::XML(response.xml, nil, "UTF-8").to_xml
+        success = true
+      rescue Exception => ex
+        return { :success => false, :xml => Nokogiri::XML(ex.http.body, nil, "UTF-8").to_xml } if ex.instance_of? Savon::SOAPFault      
+      
+        xml = Nokogiri::XML::Builder.new do |xml|
+          xml.error do
+            xml.message ex.to_s
+            xml.backtrace ex.backtrace.join("\n    ")
+          end
+        end.to_xml
+        success = false
+      end
+      
+      logger.debug "Success on request? #{success}"
+      { :success => success, :xml => xml }
+    end
+    
+    def self._savon_client(wsdl_url, ws_config, ws_security)
+      logger = AppLogger.create_logger self
+      logger.debug "Prepare web service app client"
+      
+      params = {}
+      params[:env_namespace] = ws_config.env_namespace if ws_config.env_namespace
+      params[:namespaces] = ws_config.namespaces if ws_config.namespaces
+
+      params[:ssl_verify_mode] = ws_config.ssl_verify_mode if ws_config.ssl_verify_mode
+      params[:ssl_version] = ws_config.ssl_version if ws_config.ssl_version
+      params[:ssl_cert_file] = ws_config.ssl_cert_file if ws_config.ssl_cert_file
+      params[:ssl_cert_key_file] = ws_config.ssl_cert_key_file if ws_config.ssl_cert_key_file
+      params[:ssl_ca_cert_file] = ws_config.ssl_ca_cert_file if ws_config.ssl_ca_cert_file
+      params[:ssl_cert_key_password] = ws_config.ssl_cert_key_password if ws_config.ssl_cert_key_password
+      
+      logger.debug "Client config params for requesting service: #{params}"
+      logger.debug "WS-Security params: #{ws_security}" if (!ws_security.nil? && !ws_security.empty?)
+      
+      Savon.client(params) do
+        wsdl wsdl_url
+        wsse_auth ws_security['login'], ws_security['password'], :digest if (!ws_security.nil? && !ws_security.empty?)
+      end
+    end
+  
+  end
+
+end

data/lib/report/chart_factory.rb

@@ -0,0 +1,68 @@
+module Report
+
+  class ChartFactory
+    
+    def self.success_failure_chart(opt)
+      total = opt[:total_success].to_i + opt[:total_failures].to_f
+      success = ((opt[:total_success].to_i * 100) / total).to_f.round 2
+      failures = ((opt[:total_failures].to_i * 100) / total).to_f.round 2
+      
+      str = "[{ value: #{success}, color: \"#1A0B9C\", highlight: \"#1E0CC0\", label: \"Success (%)\"},"
+      str << "{ value : #{failures}, color : \"#BF1717\", highlight: \"#D71515\", label: \"Failures (%)\"}]"
+      
+      ChartFactory._template :id => opt[:id], :data => str, :type => :pie
+    end
+    
+    def self.totals_tags_chart(opt)
+      stats = opt[:stats]
+      str = <<-eos
+{
+  labels: ["#{stats.keys.join('","')}"],
+  datasets: [{
+    fillColor: "rgba(151,187,205,0.5)",
+    strokeColor: "rgba(151,187,205,0.8)",
+    highlightFill: "rgba(151,187,205,0.75)",
+    highlightStroke: "rgba(151,187,205,1)",
+    data: [#{stats.map {|k, v| stats[k][:total] }.join(',')}]
+  }]    
+}
+eos
+      ChartFactory._template :id => opt[:id], :data => str, :type => :bar
+    end
+    
+    def self.stats_tags_chart(opt)
+      stats = opt[:stats]
+      str = <<-eos
+{
+  labels: ["#{stats.keys.join('","')}"],
+  datasets: [{
+    fillColor: "rgba(220,220,220,0.5)",
+    strokeColor: "rgba(220,220,220,0.8)",
+    highlightFill: "rgba(220,220,220,0.75)",
+    highlightStroke: "rgba(220,220,220,1)",
+    data: [#{stats.keys.map {|k| 100 }.join(',')}]
+  },
+  {
+    fillColor: "rgba(151,187,205,0.5)",
+    strokeColor: "rgba(151,187,205,0.8)",
+    highlightFill: "rgba(151,187,205,0.75)",
+    highlightStroke: "rgba(151,187,205,1)",
+    data: [#{stats.map {|k, v| stats[k][:stat] }.join(',')}]
+  }]    
+}
+eos
+      ChartFactory._template :id => opt[:id], :data => str, :type => :bar
+    end
+    
+    def self._template(opt)
+<<-eos
+  var data = #{opt[:data]};
+
+  var chart = document.getElementById("#{opt[:id]}").getContext("2d");
+  new Chart(chart).#{opt[:type].to_s.capitalize}(data, {});
+eos
+    end
+  
+  end
+
+end

data/lib/report/console.rb

@@ -0,0 +1,94 @@
+module Report
+
+  class Console < Reporter
+    
+    def print(object)
+      case object.class.name
+        when Theotokos::Model::TestResult.name then _print_test_result object
+        when Theotokos::Model::TestSuiteResult.name then _print_test_suite_result object
+        when Theotokos::Model::TestAppResult.name then _print_test_app_result object
+        else puts "Console printing is not supported for objects of type #{object.class.name}"
+      end
+    end
+    
+    private
+    def _print_test_result(test)
+      @output = ''
+      _append "Test case: ##{test.name}"
+      _append "Test description: #{test.description}"
+      _append "Tags: #{test.tags.join(', ')}" if test.tags
+      _append "Test expectations."
+      
+      if test.test_expectation && !test.status.nil?
+        if test.test_expectation['file']
+          file = test.test_expectation['file']
+          _append " => File '#{file}'\n#{File.read(Helper.format_ws_output_path file)}"
+          _append " => Status: #{test.status.test_file_status ? 'Passed' : 'Failed'}\n"
+        end
+        puts
+        if test.test_expectation['text']
+          exp = test.test_expectation['text']
+          _append " => Text\n"
+
+          exp.each do |k, v|
+            _append "#{k}: #{v}"
+            if test.status.test_text_status.nil?
+              _append "Status: Not performed"
+            else
+              status = test.status.test_text_status[k.to_sym]
+              _append "Status: #{status ? 'Passed' : 'Failed'}"
+            end
+          end
+        end          
+      end
+      
+      if test.error
+        backtrace = ((test.error[:backtrace].instance_of? Array) ? test.error[:backtrace].join("\n") : test.error[:backtrace])
+        _append "\n - Error message: #{test.error[:message]}"
+        _append "\n - Error detail:\n#{backtrace}"
+      else
+        _append "\n- Found output."
+        _append (test.test_actual) ? File.read(test.test_actual) : ''
+      end
+      
+      _append "\n- Test case status: #{((test.status.nil?) ? 'Skipped' : (test.status.success? ? 'Success' : 'Fail'))}"
+      _append "\n------\n\n"
+      
+      @output
+    end
+    
+    def _print_test_suite_result(suite)
+      @output = ''
+      _append "-" * 100
+      _append "Total test success: #{suite.total_success}"
+      _append "Total test failures: #{suite.total_failures}"
+      
+      @output
+    end
+    
+    def _print_test_app_result(app)
+      @output = ''
+      _append "*" * 100
+      _append "Total test suites success: #{app.total_success}"
+      _append "Total test suites failures: #{app.total_failures}\n"
+      
+      if app.error?
+        _append "*" * 100
+        _append "- Broken tests"
+        app.broken_suites.each do |suite|
+          _append "Test suite: #{suite.model.source}\nTest cases: ##{suite.broken_tests.map {|t| t.name }.join(', #')}"
+        end
+      end
+      
+      @output
+    end
+    
+    def _append(text)
+      @output << "\n" unless @output.empty?
+      @output << text
+      puts text unless ENV['ENVIRONMENT'] == 'test'
+    end
+  
+  end
+
+end