atp 0.8.0 → 1.0.0

data/lib/atp/processors/redundant_condition_remover.rb

@@ -0,0 +1,28 @@
+module ATP
+  module Processors
+    # Removes any conditions nodes that are nested within other condition
+    # nodes that specify the same condition
+    class RedundantConditionRemover < Processor
+      def run(node)
+        @conditions = []
+        process(node)
+      end
+
+      def on_condition_node(node)
+        sig = [node.type, node.to_a[0]]
+        if @conditions.include?(sig)
+          flag, *nodes = *node
+          node.updated(:inline, process_all(nodes))
+        else
+          @conditions << sig
+          node = node.updated(nil, process_all(node.children))
+          @conditions.pop
+          node
+        end
+      end
+      ATP::Flow::CONDITION_NODE_TYPES.each do |type|
+        alias_method "on_#{type}", :on_condition_node unless method_defined?("on_#{type}")
+      end
+    end
+  end
+end

data/lib/atp/processors/relationship.rb

@@ -11,49 +11,52 @@ module ATP
       class ExtractTestResults < Processor
         attr_reader :results
 
-        def on_test_result(node)
-          ids, state, *children = *node
+        def on_if_failed(node)
+          ids, *children = *node
           unless ids.is_a?(Array)
             ids = [ids]
           end
           ids.each do |id|
             results[id] ||= {}
-            if state
-              results[id][:passed] = true
-            else
-              results[id][:failed] = true
-            end
+            results[id][:failed] = true
           end
           process_all(children)
         end
+        alias_method :on_if_any_failed, :on_if_failed
+        alias_method :on_if_all_failed, :on_if_failed
 
-        def on_test_executed(node)
-          id, state, *children = *node
-          id, state = *node
+        def on_if_passed(node)
+          ids, *children = *node
+          unless ids.is_a?(Array)
+            ids = [ids]
+          end
+          ids.each do |id|
+            results[id] ||= {}
+            results[id][:passed] = true
+          end
+          process_all(children)
+        end
+        alias_method :on_if_any_passed, :on_if_passed
+        alias_method :on_if_all_passed, :on_if_passed
+
+        def on_if_ran(node)
+          id, *children = *node
           results[id] ||= {}
-          results[id][:executed] = true
+          results[id][:ran] = true
           process_all(children)
         end
+        alias_method :on_unless_ran, :on_if_ran
 
         def results
           @results ||= {}.with_indifferent_access
         end
       end
 
-      def process(node)
-        # On first call extract the test_result nodes from the given AST,
-        # then process as normal thereafter
-        if @first_call_done
-          result = super
-        else
-          @first_call_done = true
-          t = ExtractTestResults.new
-          t.process(node)
-          @test_results = t.results || {}
-          result = super
-          @first_call_done = false
-        end
-        result
+      def run(node)
+        t = ExtractTestResults.new
+        t.process(node)
+        @test_results = t.results || {}
+        process(node)
       end
 
       def add_pass_flag(id, node)
@@ -61,7 +64,7 @@ module ATP
         node = node.ensure_node_present(:on_fail)
         node.updated(nil, node.children.map do |n|
           if n.type == :on_pass
-            n = n.add n2(:set_run_flag, "#{id}_PASSED", :auto_generated)
+            n = n.add node.updated(:set_flag, ["#{id}_PASSED", :auto_generated])
           elsif n.type == :on_fail
             n.ensure_node_present(:continue)
           else
@@ -74,7 +77,7 @@ module ATP
         node = node.ensure_node_present(:on_fail)
         node.updated(nil, node.children.map do |n|
           if n.type == :on_fail
-            n = n.add n2(:set_run_flag, "#{id}_FAILED", :auto_generated)
+            n = n.add node.updated(:set_flag, ["#{id}_FAILED", :auto_generated])
             n.ensure_node_present(:continue)
           else
             n
@@ -82,16 +85,27 @@ module ATP
         end)
       end
 
-      def add_executed_flag(id, node)
-        node = node.ensure_node_present(:on_fail)
-        node = node.ensure_node_present(:on_pass)
-        node.updated(nil, node.children.map do |n|
-          if n.type == :on_pass || n.type == :on_fail
-            n = n.add n2(:set_run_flag, "#{id}_RAN", :auto_generated)
+      def add_ran_flags(id, node)
+        set_flag = node.updated(:set_flag, ["#{id}_RAN", :auto_generated])
+        # For a group, set a flag immediately upon entry to the group to signal that
+        # it ran to later tests
+        if node.type == :group
+          name, id, *nodes = *node
+          if id.type == :id
+            nodes.unshift(set_flag)
+            nodes.unshift(id)
           else
-            n
+            nodes.unshift(id)
+            nodes.unshift(set_flag)
           end
-        end)
+          node.updated(nil, [name] + nodes)
+        # For a test, set a flag immediately after the referenced test has executed
+        # but don't change its pass/fail handling
+        elsif node.type == :test
+          node.updated(:inline, [node, set_flag])
+        else
+          fail "Don't know how to add ran flag to #{node.type}"
+        end
       end
 
       # Set flags depending on the result on tests which have dependents later
@@ -102,7 +116,7 @@ module ATP
         if test_results[nid]
           node = add_pass_flag(nid, node) if test_results[nid][:passed]
           node = add_fail_flag(nid, node) if test_results[nid][:failed]
-          node = add_executed_flag(nid, node) if test_results[nid][:executed]
+          node = add_ran_flags(nid, node) if test_results[nid][:ran]
         end
         if node.type == :group
           node.updated(nil, process_all(node))
@@ -112,26 +126,50 @@ module ATP
       end
       alias_method :on_group, :on_test
 
-      # Remove test_result nodes and replace with references to the flags set
-      # up stream by the parent node
-      def on_test_result(node)
-        children = node.children.dup
-        id = children.shift
-        state = children.shift
-        if state
-          n(:run_flag, [id_to_flag(id, 'PASSED'), true] + process_all(children))
-        else
-          n(:run_flag, [id_to_flag(id, 'FAILED'), true] + process_all(children))
+      def on_if_failed(node)
+        id, *children = *node
+        node.updated(:if_flag, [id_to_flag(id, 'FAILED')] + process_all(children))
+      end
+      alias_method :on_if_any_failed, :on_if_failed
+
+      def on_if_all_failed(node)
+        ids, *children = *node
+        ids.reverse_each.with_index do |id, i|
+          if i == 0
+            node = node.updated(:if_flag, [id_to_flag(id, 'FAILED')] + process_all(children))
+          else
+            node = node.updated(:if_flag, [id_to_flag(id, 'FAILED'), node])
+          end
+        end
+        node
+      end
+
+      def on_if_passed(node)
+        id, *children = *node
+        node.updated(:if_flag, [id_to_flag(id, 'PASSED')] + process_all(children))
+      end
+      alias_method :on_if_any_passed, :on_if_passed
+
+      def on_if_all_passed(node)
+        ids, *children = *node
+        ids.reverse_each.with_index do |id, i|
+          if i == 0
+            node = node.updated(:if_flag, [id_to_flag(id, 'PASSED')] + process_all(children))
+          else
+            node = node.updated(:if_flag, [id_to_flag(id, 'PASSED'), node])
+          end
         end
+        node
+      end
+
+      def on_if_ran(node)
+        id, *children = *node
+        node.updated(:if_flag, [id_to_flag(id, 'RAN')] + process_all(children))
       end
 
-      # Remove test_result nodes and replace with references to the flags set
-      # up stream by the parent node
-      def on_test_executed(node)
-        children = node.children.dup
-        id = children.shift
-        state = children.shift
-        n(:run_flag, [id_to_flag(id, 'RAN'), state] + children)
+      def on_unless_ran(node)
+        id, *children = *node
+        node.updated(:unless_flag, [id_to_flag(id, 'RAN')] + process_all(children))
       end
 
       # Returns the ID of the give test node (if any), caller is responsible

data/lib/atp/runner.rb

@@ -6,8 +6,8 @@ module ATP
   class Runner < Processor
     def run(node, options = {})
       options = {
-        evaluate_flow_flags: true,
-        evaluate_run_flags:  true,
+        evaluate_enables:    true,
+        evaluate_flags:      true,
         evaluate_set_result: true
       }.merge(options)
       @options = options
@@ -31,11 +31,12 @@ module ATP
       container << node
     end
 
-    def on_flow_flag(node)
-      if @options[:evaluate_flow_flags]
-        flag, enabled, *nodes = *node
+    def on_if_flag(node)
+      if @options[:evaluate_flags]
+        flag, *nodes = *node
         flag = [flag].flatten
-        active = flag.any? { |f| flow_flags.include?(f) }
+        enabled = node.type == :if_flag
+        active = flag.any? { |f| set_flags.include?(f) }
         if (enabled && active) || (!enabled && !active)
           process_all(nodes)
         end
@@ -43,15 +44,17 @@ module ATP
         c = open_container do
           process_all(node.children)
         end
-        container << node.updated(nil, node.children.take(2) + c)
+        container << node.updated(nil, node.children.take(1) + c)
       end
     end
+    alias_method :on_unless_flag, :on_if_flag
 
-    def on_run_flag(node)
-      if @options[:evaluate_run_flags]
-        flag, enabled, *nodes = *node
+    def on_if_enabled(node)
+      if @options[:evaluate_enables]
+        flag, *nodes = *node
         flag = [flag].flatten
-        active = flag.any? { |f| run_flags.include?(f) }
+        enabled = node.type == :if_enabled
+        active = flag.any? { |f| set_enables.include?(f) }
         if (enabled && active) || (!enabled && !active)
           process_all(nodes)
         end
@@ -59,16 +62,21 @@ module ATP
         c = open_container do
           process_all(node.children)
         end
-        container << node.updated(nil, node.children.take(2) + c)
+        container << node.updated(nil, node.children.take(1) + c)
       end
     end
+    alias_method :on_unless_enabled, :on_if_enabled
 
-    # Not sure why this method is here, all test_result nodes should have been
-    # converted to run_flag nodes by now
-    def on_test_result(node)
-      id, passed, *nodes = *node
-      if (passed && !failed_test_ids.include?(id)) ||
-         (!passed && failed_test_ids.include?(id))
+    def on_if_failed(node)
+      id, *nodes = *node
+      if failed_test_ids.include?(id)
+        process_all(nodes)
+      end
+    end
+
+    def on_if_passed(node)
+      id, *nodes = *node
+      unless failed_test_ids.include?(id)
         process_all(nodes)
       end
     end
@@ -77,7 +85,7 @@ module ATP
       if id = node.find(:id)
         id = id.to_a[0]
         if failed_test_ids.include?(id)
-          node = node.add(n0(:failed))
+          node = node.add(node.updated(:failed, []))
           failed = true
           if n_on_fail = node.find(:on_fail)
             node = node.remove(n_on_fail)
@@ -155,16 +163,16 @@ module ATP
       end
     end
 
-    def on_set_run_flag(node)
-      run_flags << node.to_a[0]
+    def on_set_flag(node)
+      set_flags << node.to_a[0]
     end
 
-    def on_enable_flow_flag(node)
-      flow_flags << node.value unless flow_flags.include?(node.value)
+    def on_enable(node)
+      set_enables << node.value unless set_enables.include?(node.value)
     end
 
-    def on_disable_flow_flag(node)
-      flow_flags.delete(node.value)
+    def on_disable(node)
+      set_enables.delete(node.value)
     end
 
     def on_log(node)
@@ -172,9 +180,10 @@ module ATP
     end
     alias_method :on_render, :on_log
 
-    def on_job(node)
-      jobs, state, *nodes = *node
+    def on_if_job(node)
+      jobs, *nodes = *node
       jobs = clean_job(jobs)
+      state = node.type == :if_job
       unless job
         fail 'Flow contains JOB-based conditions and no current JOB has been given!'
       end
@@ -184,6 +193,7 @@ module ATP
         process_all(node) unless jobs.include?(job)
       end
     end
+    alias_method :on_unless_job, :on_if_job
 
     def clean_job(job)
       [job].flatten.map { |j| j.to_s.upcase }
@@ -197,13 +207,13 @@ module ATP
       @failed_test_ids ||= [@options[:failed_test_id] || @options[:failed_test_ids]].flatten.compact
     end
 
-    def run_flags
-      @run_flags ||= []
+    def set_flags
+      @set_flags ||= []
     end
 
     # Returns an array of enabled flow flags
-    def flow_flags
-      @flow_flags ||= [@options[:flow_flag] || @options[:flow_flags]].flatten.compact
+    def set_enables
+      @set_enables ||= [@options[:enable] || @options[:enables]].flatten.compact
     end
 
     def completed?

data/lib/atp/validator.rb

@@ -3,6 +3,14 @@ module ATP
   class Validator < Processor
     attr_reader :flow
 
+    def self.testing=(value)
+      @testing = value
+    end
+
+    def self.testing
+      @testing
+    end
+
     def initialize(flow)
       @flow = flow
     end
@@ -30,5 +38,16 @@ module ATP
 
     def setup
     end
+
+    def error(message)
+      # This is a hack to make the specs pass, for some reason RSpec
+      # seems to be swallowing the Origen log output after the first
+      # test that generates an error
+      if Validator.testing
+        puts message
+      else
+        Origen.log.error(message)
+      end
+    end
   end
 end

data/lib/atp/validators/duplicate_ids.rb

@@ -4,9 +4,9 @@ module ATP
       def on_completion
         if @duplicate_ids
           @duplicate_ids.each do |id, nodes|
-            Origen.log.error "Test ID #{id} is defined more than once in flow #{flow.name}:"
+            error "Test ID #{id} is defined more than once in flow #{flow.name}:"
             nodes.each do |node|
-              Origen.log.error "  #{node.source}"
+              error "  #{node.source}"
             end
           end
           true

data/lib/atp/validators/jobs.rb

@@ -9,23 +9,23 @@ module ATP
       def on_completion
         failed = false
         unless @conflicting.empty?
-          Origen.log.error 'if_job and unless_job conditions cannot both be applied to the same tests'
-          Origen.log.error "The following conflicts were found in flow #{flow.name}:"
+          error 'if_job and unless_job conditions cannot both be applied to the same tests'
+          error "The following conflicts were found in flow #{flow.name}:"
           @conflicting.each do |a, b|
             a_condition = a.to_a[1] ? 'if_job:    ' : 'unless_job:'
             b_condition = b.to_a[1] ? 'if_job:    ' : 'unless_job:'
-            Origen.log.error "  #{a_condition} #{a.source}"
-            Origen.log.error "  #{b_condition} #{b.source}"
-            Origen.log.error ''
+            error "  #{a_condition} #{a.source}"
+            error "  #{b_condition} #{b.source}"
+            error ''
           end
           failed = true
         end
 
         unless @negative.empty?
-          Origen.log.error 'Job names should not be negated, use unless_job if you want to specify !JOB'
-          Origen.log.error "The following negative job names were found in flow #{flow.name}:"
+          error 'Job names should not be negated, use unless_job if you want to specify !JOB'
+          error "The following negative job names were found in flow #{flow.name}:"
           @negative.each do |node|
-            Origen.log.error "  #{node.to_a[0]} #{node.source}"
+            error "  #{node.to_a[0]} #{node.source}"
           end
           failed = true
         end
@@ -33,9 +33,10 @@ module ATP
         failed
       end
 
-      def on_job(node)
-        jobs, state, *nodes = *node
+      def on_if_job(node)
+        jobs, *nodes = *node
         jobs = [jobs].flatten
+        state = node.type == :if_job
         if jobs.any? { |j| j.to_s =~ /^(!|~)/ }
           @negative << node
         end
@@ -48,6 +49,7 @@ module ATP
           @stack.pop
         end
       end
+      alias_method :on_unless_job, :on_if_job
     end
   end
 end