semilla 0.0.2

data/lib/semilla/report_server.rb

@@ -0,0 +1,153 @@
+require "socket"
+require "timeout"
+
+module Semilla
+
+  class FlexUnitReportServer
+
+    attr_accessor :results
+    attr_reader :error
+
+    START_ACK          = "<startOfTestRunAck/>"
+    END_TEST           = "<endOfTestRun/>"
+    END_TEST_ACK       = "<endOfTestRunAck/>"
+    POLICY_REQUEST     = "<policy-file-request/>"
+    EOF                = "\0"
+    SOCKET_POLICY_FILE = <<EOS
+<?xml version="1.0"?>
+<!DOCTYPE cross-domain-policy SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">
+<cross-domain-policy>
+  <allow-access-from domain="*" to-ports="@@@"/>
+</cross-domain-policy>
+EOS
+
+
+    def initialize(port=1026)
+      @port   = port
+      @addr   = "127.0.0.1"
+      @server = nil #This will be our socket server
+      @error  = false
+    end
+
+
+    def start(timeout=10)
+      @server = TCPServer.new(@addr, @port)
+      #view server data
+      puts @server.addr
+
+      #open the socket
+      puts "Opening server at port #{@port}"
+
+      #--------------------------------------------------------------
+      #the report result will be here
+      report = ""
+
+      loop {
+        puts "Waiting for client..."
+
+        begin
+          #Wait with a timeout
+          client = Timeout::timeout timeout do
+            @server.accept
+          end
+            #No client connected within the time limit, bail out
+        rescue Timeout::Error
+          puts "Timeout!!, no client connected!!!"
+          @error = true
+          break
+        end
+        puts "Client connected..."
+        puts "Receiving data"
+        #Tell FlexUnit to start sending stuff
+        client.puts START_ACK + EOF
+        #puts "[OUT] #{START_ACK}"
+        report = "<report>"
+        error  = false
+        while received = receiveWithTimeout(client, timeout)
+          unless received != ""
+            finished = true
+            puts "empty data!!"
+            error = true
+            break
+          end
+          #puts received
+          putc '.'
+          #clean up the text
+          received.rstrip!
+          received.chomp!
+
+          #print out for debug
+          #puts "[IN] #{received}"
+
+          #check for policy file
+          if received.include? POLICY_REQUEST
+            self.sendPolicyFile client
+            client.close
+            puts "[OUT] Sending policy File"
+            break
+          end
+
+          if received.include? END_TEST
+
+            #the last message may contain some data as well
+            report = report + received.sub(END_TEST, "")
+
+            puts
+            puts "Closing connection"
+            #Test ended, send ACK to client
+            client.puts END_TEST_ACK + EOF
+            client.flush
+            client.close
+            finished = true
+            report   = report + "</report>"
+            break
+          end
+
+          report = report + received
+
+        end
+
+        if error
+          report = nil
+        end
+        break if finished
+
+
+      }
+      #Parse the xml from flexunit and generate the report files.
+      puts "bye bye"
+      #sanitize the results string
+      @results = report.delete "\000" unless report.nil?
+      #---------------------------------------------------------------
+
+    end
+
+
+    def policyFile
+      return SOCKET_POLICY_FILE.sub "@@@", @port #replace the @@@ for the port number
+    end
+
+
+    def sendPolicyFile(client)
+      puts "Sending policy file."
+      #Send policy stuff
+      client.puts self.policyFile
+      client.flush
+    end
+
+
+    def receiveWithTimeout(client, timeout)
+
+      begin
+        r = Timeout::timeout timeout do
+          client.recv(1024)
+        end
+      rescue Timeout::Error
+        "" #Timed out, return an empty string
+      end
+
+    end
+
+  end
+
+end

data/lib/semilla/reports.rb

@@ -0,0 +1,203 @@
+require 'rexml/document'
+require 'rexml/formatters/default'
+require 'socket'
+require 'time'
+
+
+module Semilla
+
+#Define a test case
+  class FlexUnitTestCase
+
+    attr_accessor :classname, :name, :time, :status, :msg
+
+
+    def initWith(xml)
+      #parse tag
+      if xml.is_a? String
+        doc = REXML::Document.new xml
+      else
+        doc = REXML::Document.new
+        doc.add_element xml
+      end
+
+
+      @classname = doc.root.attribute("classname").value.sub "::", "." #Change the :: to .
+      @name      = doc.root.attribute("name").value                    #method name
+      @time      = doc.root.attribute("time").value.to_i / 1000.0      #time to milliseconds
+      @status    = doc.root.attribute("status").value                  #status
+      @msg = doc.root.elements[1] if doc.root.elements.count > 0
+
+
+      #If time is reported as 0 by flex unit, set to 1 millisecond
+      #@time = 1/1000.0 if @time == 0
+    end
+
+
+    def toXml
+      element = REXML::Element.new "testcase"
+      element.add_attribute "classname", @classname
+      element.add_attribute "name", @name
+      element.add_attribute "time", @time
+      element.add_attribute "status", @status
+      element.add_element @msg unless @msg.nil?
+
+      return element
+    end
+  end
+
+#Defin a test suite
+  class FlexUnitTestSuite
+
+    def initialize
+      @testCases = Array.new
+      @classname = ""
+      @totalTime = 0.0
+      @id        = 0
+    end
+
+
+    attr_reader :totalTime, :classname
+    attr_accessor :id
+
+
+    def addCase(tc)
+      if tc.is_a? FlexUnitTestCase
+        @classname = tc.classname
+        @testCases << tc
+        @totalTime = @totalTime + tc.time
+      end
+    end
+
+
+    def testCount
+      @testCases.count
+    end
+
+
+    def name
+      return @classname[/[^\.]*$/] #Get the text at the end of the line after the last dot
+    end
+
+
+    def package
+      if @classname.include? "."
+        @classname[/(?<package>.*)([\.])/, "package"]
+        #using named captures check: "?<package>"
+      else
+        ""
+      end
+    end
+
+
+    def failures
+      return @testCases.count { |tc| tc.status == "failure" }
+    end
+
+
+    def errors
+      return @testCases.count { |tc| tc.status == "error" }
+    end
+
+
+    def ignores
+      return @testCases.count { |tc| tc.status == "ignore" }
+    end
+
+
+    def toXml
+      element = REXML::Element.new "testsuite"
+      element.add_attribute "hostname", Socket.gethostname
+      element.add_attribute "id", self.id
+      #element.add_attribute "package", self.package
+      element.add_attribute "name", self.classname
+      element.add_attribute "tests", self.testCount
+      element.add_attribute "failures", self.failures
+      element.add_attribute "errors", self.errors
+      element.add_attribute "skipped", self.ignores
+      element.add_attribute "time", self.totalTime
+      element.add_attribute "timestamp", Time.now.utc.iso8601
+
+      @testCases.each do |tc|
+        element.add_element tc.toXml
+      end
+
+      return element
+    end
+
+  end
+
+
+  def self.writePrettyXml(element, filename)
+    #create anew xml document
+    outdoc         = REXML::Document.new
+
+    #Create the xml declaration
+    xmldeclaration = REXML::XMLDecl.new
+    xmldeclaration.dowrite
+    xmldeclaration.encoding = "UTF-8"
+    outdoc << xmldeclaration
+
+    #Add the element
+    outdoc << element
+
+    #Write to a file
+    f         = File.new filename, "w"
+    formatter = REXML::Formatters::Pretty.new
+    formatter.write(outdoc, f)
+    f.close
+  end
+
+
+#converts an xml report from flash, into an array of FlexUnitTestSuite
+  def self.processReports(xmlresults)
+
+    testResults = REXML::Document.new xmlresults
+
+    suites = Hash.new
+
+    testResults.elements.each "report/testcase" do |element|
+
+      #Create the testcase
+      tc = FlexUnitTestCase.new
+      tc.initWith element
+
+      #Check if we dont have a suite for the classname
+      unless suites.has_key? tc.classname
+        #make a new suite
+        s                    = FlexUnitTestSuite.new
+        suites[tc.classname] = s
+      end
+
+      suite = suites[tc.classname]
+      suite.addCase tc
+      puts "    [TestCase] #{tc.classname} => #{tc.name}, #{tc.status}"
+    end
+
+    return suites
+  end
+
+
+#writes junit xml files for each item in the suites hash
+  def self.createReports(suites, outfolder = "test-report")
+
+    testcount   = 0
+    testfails   = 0
+    testerr     = 0
+    testignores = 0
+    suites.each do |name, suite|
+      #write individual report file
+      writePrettyXml suite.toXml, "#{outfolder}/TEST-#{suite.classname}.xml"
+      testcount   += suite.testCount
+      testfails   += suite.failures
+      testerr     += suite.errors
+      testignores += suite.ignores
+    end
+
+    testPassed = testcount - testfails - testerr - testignores
+    testok     = testPassed.to_f / testcount.to_f * 100.0
+    puts "Success [#{testPassed}/#{testcount}] #{sprintf('%.1f', testok)}%, Fails [#{testfails}], Errors [#{testerr}], Ignored [#{testignores}]"
+    return testfails + testerr
+  end
+
+end

data/lib/semilla/test.rb

@@ -0,0 +1,95 @@
+
+require "rexml/document"
+require "rake"
+require 'timeout'
+require 'flashplayer/trust'
+
+require_relative "reports"
+require_relative "report_server"
+
+
+module Semilla
+  class FlexUnitTestTask < Rake::Task
+
+    attr_accessor :serverPort, :player, :swf, :reportpath, :timeout
+
+
+    def initialize(task_name, app)
+      super task_name, app
+
+      @serverPort = 1024
+      @player     = ENV['FLASH_PLAYER']
+      @reportpath = "test-report"
+      @timeout    = 10 #seconds
+    end
+
+
+    def execute(arg = nil)
+      super arg
+
+      ##Check the parameters
+      if @serverPort.nil?
+        fail "Server port not specified."
+      end
+
+      if @swf.nil?
+        fail "No swf path specified."
+      end
+
+      if @reportpath.nil?
+        fail "No report path specified."
+      end
+
+      #Writeout the FlashPlayerTrust file
+      trust = FlashPlayer::Trust.new
+      trust.add File.dirname(@swf)
+
+      puts "[TEST] Start"
+      server       = FlexUnitReportServer.new @serverPort
+      serverThread = Thread.new {
+        #Start the server for getting the flex unit results
+        server.start @timeout
+      }
+      sleep 0.5
+
+      #launch flash
+      clientThread = Thread.new {
+
+        begin
+          status = Timeout::timeout @timeout do
+            flashbin = ENV['FLASH_PLAYER']
+            #Run the flash player
+            puts "Running flash..."
+            command = "\"#{flashbin}\" \"#{@swf}\""
+            puts command
+            fr = %x[#{command}]
+          end
+        rescue Timeout::Error
+          fail "Flash player timeout!!!"
+        end
+      }
+
+
+      #Wait until finished
+      serverThread.join
+      clientThread.join
+
+      #parse the reports
+      suites    = Semilla::processReports server.results
+      #generate junit report
+      failcount = Semilla::createReports suites, @reportpath
+      puts "[TEST] Done"
+
+      fail "Unit tests failed." if failcount > 0
+
+    end
+
+  end
+
+
+  def self.flex_unit(*args, &body)
+    FlexUnitTestTask.define_task(*args, &body)
+  end
+
+
+end

data/lib/semilla/test_runner.rb

@@ -0,0 +1,87 @@
+require "rake"
+
+module Semilla
+
+  class TestCaseFile
+    attr_accessor :path
+
+    #Constructor. The parameter should be a string from rake
+    def initialize(fpath)
+      @path = fpath
+    end
+
+
+    #The file name without extension
+    def name
+      @path.pathmap '%n'
+    end
+
+
+    #Get the package name from the contents of the file
+    def package
+      if !@_package
+        #Open the file
+        File.open @path do |io|
+          io.each do |line|
+            #Search for the package name
+            if line =~ /^package (.*)/
+              @_package = $1.rstrip
+            end
+          end
+          #no package name found, set to empty string
+          @_package = "" if !@_package
+        end
+      end
+      return @_package
+    end
+
+
+    #The import statement for this class
+    def import
+      if self.package != ""
+        return "#{self.package}.#{self.name}"
+      else
+        return self.name
+      end
+    end
+  end
+
+
+######################################################################
+#Define a rake task for auto generating the TestRunner code
+  def self.test_runner(output, files, port=1026, template="test-src/TestRunner.template")
+    #Prepare arguments for the FileTask
+    files.include template
+    args = Array.new
+    args << {output => files} #target file => dependencies
+
+    body = proc {
+      #create the test case generators
+      generators = Array.new
+      files.each do |f|
+        tc = TestCaseFile.new f
+        puts "[testRunner] Adding: #{tc.import}"
+        generators << tc
+      end
+      #open the template and insert the import statements and class list
+      File.open template do |io|
+        txt = io.read
+        #insert import list
+        txt.sub! "@@IMPORTS@@", generators.map { |t| "\timport #{t.import};" }.join("\n")
+        #insert class names
+        txt.sub! "@@CLASSES@@", generators.map { |t| t.name }.join(",")
+        #insert port number
+        txt.sub! "@@PORT@@", port.to_s
+
+        #write the generated code
+        generated = File.new output, "w"
+        generated.write txt
+        generated.close
+      end
+    }
+
+    #Create the file task (checks for dependency updates for us)
+    Rake::FileTask.define_task(*args, &body)
+  end
+
+end

data/lib/semilla/version.rb

@@ -0,0 +1,3 @@
+module Semilla
+  VERSION = '0.0.2'
+end

data/lib/semilla.rb

@@ -0,0 +1,36 @@
+
+
+require 'semilla/report_server'
+require 'semilla/reports'
+require 'semilla/test'
+require 'semilla/test_runner'
+
+
+## Rake usage
+
+=begin
+
+#################################################################
+# Rake task to create the test runner actionscript
+#
+# @param output file
+# @param test classes file list
+# @param report server port
+Semilla::test_runner "outputfile.as", FileList["test-src/**/*Test.as"], 1026
+
+#################################################################
+# Rake task to test a swf and get a report in junit xml format.
+#
+# @param task id
+# @param dependencies
+Semilla::flex_unit :taskname => [dependencies]] do |t|
+   #Configuration options
+   #    serverPort :player, :swf, :reportpath, :timeout
+   #    serverPort :player, :swf, :reportpath, :timeout
+   t.serverPort = 1026
+   t.swf = "app.swf"
+   t.reportpath = "reports"
+   t.timeout = 10
+end
+
+=end

data/rakefile.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'rake/clean'
+require 'rake'
+require_relative "lib/semilla/version"
+
+
+version = Semilla::VERSION
+gemfile = "semilla-#{version}.gem"
+gemspecfile = "semilla.gemspec"
+########################################################################################################################
+
+#####################################
+#Clean
+CLEAN << FileList["*.gem"]
+
+
+#####################################
+#Build the gem file
+file gemfile => [gemspecfile] do |t|
+  sh "gem build #{gemspecfile}"
+end
+
+desc "Builds the gem"
+task :build => gemfile
+
+####################################
+desc "Uninstall the gem"
+task :uninstall do |t|
+  sh "gem uninstall semilla"
+end
+
+##################################
+desc "Install the gem"
+task :install => :build do |t|
+  sh "gem install #{gemfile}"
+end
+
+##################################
+task :default => [:clean, :build, :install]

data/semilla.gemspec

@@ -0,0 +1,45 @@
+
+# -*- encoding: utf-8 -*-
+#$:.push('lib')
+require "semilla/version"
+
+Gem::Specification.new do |s|
+  s.name     = "semilla"
+  s.version  = Semilla::VERSION.dup
+  s.date     = "2011-12-26"
+  s.summary  = "Rake tasks for flexunit4"
+  s.email    = "support@semilla.com"
+  s.homepage = "http://todo.project.com/"
+  s.authors  = ['Victor G. Rosales']
+  
+  s.description = <<-EOF
+Rake tasks for executing flex unit 4 tests.
+It should be used in addition to the sprout gem.
+EOF
+  
+  dependencies = [
+    # Examples:
+    # [:runtime,     "rack",  "~> 1.1"],
+    # [:development, "rspec", "~> 2.1"],
+      [:sprout_flashsdk, "flashsdk", "~> 1.0"]
+  ]
+  
+  s.files         = Dir['**/*']
+  s.test_files    = Dir['test/**/*'] + Dir['spec/**/*']
+  s.executables   = Dir['bin/*'].map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  
+  ## Make sure you can build the gem on older versions of RubyGems too:
+  s.rubygems_version = "1.8.13"
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.specification_version = 3 if s.respond_to? :specification_version
+  
+  dependencies.each do |type, name, version|
+    if s.respond_to?("add_#{type}_dependency")
+      s.send("add_#{type}_dependency", name, version)
+    else
+      s.add_dependency(name, version)
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: semilla
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Victor G. Rosales
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: flashsdk
+  requirement: &21744840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *21744840
+description: ! 'Rake tasks for executing flex unit 4 tests.
+
+  It should be used in addition to the sprout gem.
+
+'
+email: support@semilla.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/semilla/reports.rb
+- lib/semilla/report_server.rb
+- lib/semilla/test.rb
+- lib/semilla/test_runner.rb
+- lib/semilla/version.rb
+- lib/semilla.rb
+- rakefile.rb
+- semilla.gemspec
+homepage: http://todo.project.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.13
+signing_key: 
+specification_version: 3
+summary: Rake tasks for flexunit4
+test_files: []