cloud-toaster 1.1.2

data/lib/toaster/state/transition_edge.rb

@@ -0,0 +1,65 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+module Toaster
+
+  class TransitionEdge 
+
+    attr_accessor :node_from, :node_to, :disjunctive_conditions, :transition
+
+    def initialize(node_from, node_to, conditions=[], transition=nil)
+      @node_from = node_from
+      @node_to = node_to
+      @disjunctive_conditions = conditions
+      @disjunctive_conditions = [] if !conditions
+      @transition = transition
+    end
+
+    # each state transition represents the execution of an automation task
+    def represented_task()
+      t = @node_to.preceding_task()
+      if @node_from.properties.include?("__task_num__") && @node_to.properties.include?("__task_num__")
+        # in a "backwards" transition no particular task execution is represented
+        if @node_from.properties["__task_num__"] > @node_to.properties["__task_num__"]
+          return nil
+        end
+      end
+      return t if t
+      return @node_from.succeeding_task
+    end
+
+    def matches_parameters?(task_parameters)
+      @disjunctive_conditions.each do |condition|
+        all_contained = true
+        condition.each do |key,value|
+          contained = false
+          task_parameters.each do |tp_key,tp_val|
+            if key == tp_key
+              if value.eql?(tp_val)
+                contained = true
+                break
+              end
+            end
+          end
+          if !contained
+            all_contained = false
+            break
+          end
+        end
+        return true if all_contained
+      end
+      return false
+    end
+
+    def matches_states?(prestate, poststate)
+      return false if !@node_from.subset_of?(prestate)
+      return false if !@node_to.subset_of?(poststate)
+      return true
+    end
+
+  end
+
+end

data/lib/toaster/test/test_attribute.rb

@@ -0,0 +1,19 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+include Toaster
+
+module Toaster
+  class TestAttribute < KeyValuePair
+
+    belongs_to :test_case
+
+    def self.from_hash(hash)
+      super(hash, TestAttribute)
+    end
+
+  end
+end

data/lib/toaster/test/test_case.rb

@@ -0,0 +1,175 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/util/timestamp"
+require "toaster/model/automation_run"
+require "toaster/test/test_suite"
+require "toaster/test/test_attribute"
+
+include Toaster
+
+module Toaster
+  class TestCase < ActiveRecord::Base
+
+    belongs_to :test_suite
+    belongs_to :automation_run
+    has_many :test_attributes, nil, {:autosave => true, :dependent => :delete_all}
+    serialize :skip_task_uuids, JSON
+    serialize :repeat_task_uuids, JSON
+
+    def initialize(attr_hash)
+      if !attr_hash[:uuid]
+        attr_hash[:uuid] = Util.generate_short_uid()
+      end
+      if !attr_hash[:skip_task_uuids]
+        attr_hash[:skip_task_uuids] = []
+      end
+      if !attr_hash[:repeat_task_uuids]
+        attr_hash[:repeat_task_uuids] = []
+      end
+      super(attr_hash)
+    end
+
+    def executed?
+      return !automation_run.nil? && !automation_run.end_time.nil?
+    end
+    def scheduled?
+      return !start_time.nil?
+    end
+    def running_or_scheduled?
+      return scheduled? && !executed?
+    end
+
+    def delete_test_result()
+      # delete all task executions
+      automation_run.task_executions.each do |exe|
+        exe.delete
+      end
+      # delete automation run
+      automation_run.delete
+      # reset properties and save
+      automation_run = nil
+      start_time = 0
+      end_time = nil
+      save()
+    end
+
+    def create_chef_node_attrs()
+      attrs = {
+        "toaster_testing" => {
+          # set task IDs which are to be skipped during the test execution
+          "skip_tasks" => skip_task_uuids.dup,
+          # set task IDs which are to be repeated during the test execution
+          # (for testing idempotence)
+          "repeat_tasks" => repeat_task_uuids.dup,
+          "user_id" => test_suite.user.id,
+          "automation_uuid" => test_suite.automation.uuid
+        }
+      }
+      return attrs
+    end
+
+    def run_attributes()
+      return [] if !automation_run
+      return automation_run.run_attributes.to_a.dup
+    end
+
+    def executed_task_uuids()
+      result = []
+      if automation_run
+        automation_run.task_executions.each do |exec|
+          result << exec.task.uuid
+        end
+      end
+      return result
+    end
+
+    def repeated_tasks(only_task_names=false)
+      if !automation_run
+        return []
+      end
+      result = repeat_task_uuids.collect { |t|
+        if t.kind_of?(Array)
+          t.collect { |t1|
+            task = automation_run.automation.get_task(t1, true)
+            only_task_names ? task.name : task
+          }
+        else
+          task = automation_run.automation.get_task(t, true)
+          only_task_names ? task.name : task
+        end
+      }
+      return result
+    end
+
+    def get_gross_duration()
+      return (end_time && start_time) ? (end_time.to_i - start_time.to_i) : 0
+    end
+
+    def get_net_duration()
+      r = automation_run
+      time = 0
+      if r
+        r.task_executions.each do |exec|
+          time += exec.end_time - exec.start_time
+        end
+      end
+      return time
+    end
+    
+    def task_executions(task_uuid=[])
+      task_uuid = [task_uuid] if !task_uuid.kind_of?(Array)
+      return [] if !automation_run
+      automation_run.task_executions.each do |exec|
+        if task_uuid.empty? || task_uuid.include?(exec.task.uuid)
+          result << exec
+        end
+      end
+    end
+
+    def task_execution(task_uuid)
+      list = task_executions(task_uuid)
+      return nil if list.empty?
+      if list.size != 1
+        puts "WARN: Expected 1 task execution, got #{list.size}; for task uuid: #{task_uuid}"
+      end
+      return list[0]
+    end
+
+    def success
+      return automation_run ? automation_run.success : nil
+    end
+
+    def hash()
+      h = 0
+      h += skip_task_uuids.hash
+      h += repeat_task_uuids.hash
+      h += test_suite.uuid.hash
+      h += test_attributes ? test_attributes.hash : 0
+      return h
+    end
+
+    def ==(obj)
+      return eql?(obj)
+    end
+
+    def eql?(obj)
+      return false if !obj.kind_of?(TestCase)
+      return true if uuid && (uuid == obj.uuid)
+      attr1 = test_attributes(false) ? test_attributes(false) : {}
+      attr2 = obj.test_attributes(false) ? obj.test_attributes(false) : {}
+      return skip_task_uuids == obj.skip_task_uuids &&
+              repeat_task_uuids == obj.repeat_task_uuids &&
+              test_suite.uuid == obj.test_suite.uuid && 
+              attr1 == attr2
+    end
+
+    def self.find(criteria={})
+      DB.find_activerecord(TestCase, criteria)
+    end
+
+  end
+end

data/lib/toaster/test/test_coverage.rb

@@ -0,0 +1,147 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/test/test_coverage_goal"
+
+include Toaster
+
+module Toaster
+
+  class TestCoverage
+
+    attr_accessor :test_suite, :state_graph
+
+    def initialize(test_suite, state_graph = nil)
+      @state_graph = state_graph
+      @test_suite = test_suite
+      if !state_graph
+        automation = test_suite.automation
+        @state_graph = StateTransitionGraph.build_graph_for_test_suite(@test_suite)
+      end 
+    end
+
+    def cvg_states()
+      return covered_states().size.to_f / @state_graph.nodes().size.to_f
+    end
+
+    def test_executed?(test_case)
+      executed_tests = @test_suite.test_cases
+      skip_task_uuids = test_case.skip_task_uuids
+      repeat_task_uuids = test_case.repeat_task_uuids
+      attrs = test_case.test_attributes
+
+      executed_tests.each do |t|
+        # check skip_task_uuids
+        if t.skip_task_uuids.eql?(skip_task_uuids)
+          # check repeat_task_uuids
+          if t.repeat_task_uuids.eql?(repeat_task_uuids)
+            # check automation run attributes
+            if t.automation_run
+              attrs1 = t.automation_run.run_attributes
+              if attrs1.eql?(attrs)
+                puts "INFO: test case already executed: skip_tasks: #{skip_task_uuids}, repeat_tasks: #{repeat_task_uuids}, attributes: #{attrs}"
+                return true
+              end
+            end
+          end
+        end
+      end
+      return false
+    end
+
+    def covered_transitions()
+      result = Set.new
+      executed_tests = @test_suite.test_cases
+      @state_graph.edges().each do |e|
+        tests = tests_covering_transition(e, true)
+        if !tests.empty?()
+          result << e
+        end
+      end
+      return result
+    end
+
+    def covered_states()
+      result = Set.new
+      executed_tests = @test_suite.test_cases
+      @state_graph.nodes().each do |n|
+        tests = tests_covering_state(n, true)
+        if !tests.empty?()
+          result << n
+        end
+      end
+      return result
+    end
+
+    def tests_covering_state(state_node, return_after_first_result=false)
+      result = Set.new
+      executed_tests = @test_suite.test_cases
+      pre_task = state_node.preceding_task
+      suc_task = state_node.succeeding_task
+
+      executed_tests.each do |test|
+        # check if the post-state of the pre-task of the 
+        # given state matches for this test execution
+        if pre_task
+          exec = test.task_execution(pre_task.uuid)
+          if exec
+            poststate = exec.state_after()
+            if state_node.subset_of?(poststate, ["__task_num__"])
+              result << test
+              return result if return_after_first_result
+              next
+            end
+          end
+        end
+        # check if the pre-state of the post-task of the 
+        # given state matches for this test execution
+        if suc_task
+          exec = test.task_execution(suc_task.uuid)
+          if exec
+            prestate = exec.state_before
+            if state_node.subset_of?(prestate, ["__task_num__"])
+              result << test
+              return result if return_after_first_result
+            end
+          end
+        end
+      end
+
+      return result
+    end
+
+    def tests_covering_transition(transition_edge, return_after_first_result=false)
+      result = Set.new
+      task = transition_edge.represented_task
+      executed_tests = @test_suite.test_cases
+      executed_tests.each do |test|
+        # check if task has been executed by test case
+        if !test.executed_task_uuids().include?(task.uuid)
+          next
+        end
+        exec = test.task_execution(task.uuid)
+
+        # check if the task parameters match the transition condition
+        params = exec.get_used_parameters()
+        if !transition_edge.matches_parameters?(params)
+          next
+        end
+
+        # check if the pre-state and post-state match
+        prestate = exec.state_before()
+        poststate = exec.state_after()
+        if !transition_edge.matches_states?(prestate, poststate)
+          next
+        end
+
+        # all tests passed, add to result
+        result << test
+        return result if return_after_first_result
+      end
+    end
+
+  end
+end

data/lib/toaster/test/test_coverage_goal.rb

@@ -0,0 +1,108 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "active_record"
+
+include Toaster
+
+module Toaster
+
+  class CombinationCoverage
+    SKIP_N = 1
+    SKIP_N_SUCCESSIVE = 2
+    COMBINE_N = 3
+    COMBINE_N_SUCCESSIVE = 4
+  end
+
+  class StateGraphCoverage
+    STATES = 1
+    TRANSITIONS = 2
+    TRANSITION_PAIRS = 3
+    FULL_SEQUENCE = 4
+  end
+
+  class TestCoverageGoal < ActiveRecord::Base
+    #attr_accessor :idempotence, :combinations, :repeat_N, :optimize_for_rendering, :graph, :only_connect_to_start
+    attr_accessor :optimize_for_rendering
+
+    serialize :idempotence, JSON
+    serialize :combinations, JSON
+
+    def initialize(attr_hash={})
+      if !attr_hash
+        attr_hash = {}
+      end
+      super(attr_hash)
+      init()
+    end
+
+    def self.create(idempotence_N=0, 
+          skip_N=[], skip_N_successive=[], 
+          combine_N=[], combine_N_successive=[], 
+          graph_coverage = StateGraphCoverage::STATES,
+          only_connect_to_start = true
+      )
+      tcg = TestCoverageGoal.new
+      tcg.init(idempotence_N, skip_N, skip_N_successive,
+        combine_N, combine_N_successive, graph_coverage,
+        only_connect_to_start)
+      return tcg
+    end
+
+    def init(idempotence_N=0, 
+          skip_N=[], skip_N_successive=[], 
+          combine_N=[], combine_N_successive=[], 
+          graph_coverage = StateGraphCoverage::STATES,
+          only_connect_to_start = true
+      )
+      tcg = self
+      tcg.idempotence = idempotence_N
+      tcg.combinations = {
+        CombinationCoverage::SKIP_N => skip_N ? skip_N : [],
+        CombinationCoverage::SKIP_N_SUCCESSIVE => skip_N_successive ? skip_N_successive : [],
+        CombinationCoverage::COMBINE_N => combine_N ? combine_N : [],
+        CombinationCoverage::COMBINE_N_SUCCESSIVE => combine_N_successive ? combine_N_successive : []
+      }
+      tcg.graph = graph_coverage ? graph_coverage : StateGraphCoverage::STATES
+      tcg.only_connect_to_start = only_connect_to_start
+      tcg.repeat_N = 1
+      tcg.optimize_for_rendering = false
+    end
+    def set_only_connect_to_start(do_only_connect_to_start)
+      only_connect_to_start = do_only_connect_to_start
+      return self
+    end
+    def set_repeat_N(repeat_N)
+      repeat_N = repeat_N
+      return self
+    end
+#    def to_hash(exclude_fields = [], additional_fields = {}, recursion_fields = [])
+#      return {
+#        "idemN" => @idempotence,
+#        "comb" => {
+#          "c#{CombinationCoverage::SKIP_N}" => @combinations[CombinationCoverage::SKIP_N],
+#          "c#{CombinationCoverage::SKIP_N_SUCCESSIVE}" => @combinations[CombinationCoverage::SKIP_N_SUCCESSIVE],
+#          "c#{CombinationCoverage::COMBINE_N}" => @combinations[CombinationCoverage::COMBINE_N],
+#          "c#{CombinationCoverage::COMBINE_N_SUCCESSIVE}" => @combinations[CombinationCoverage::COMBINE_N_SUCCESSIVE]
+#        },
+#        "graph" => @graph,
+#        "only_connect_to_start" => @only_connect_to_start
+#      }
+#    end
+#    def self.from_hash(hash)
+#      return TestCoverageGoal.new(
+#        hash["idemN"], 
+#        hash["comb"]["c#{CombinationCoverage::SKIP_N}"],
+#        hash["comb"]["c#{CombinationCoverage::SKIP_N_SUCCESSIVE}"],
+#        hash["comb"]["c#{CombinationCoverage::COMBINE_N}"],
+#        hash["comb"]["c#{CombinationCoverage::COMBINE_N_SUCCESSIVE}"],
+#        hash["graph"],
+#        hash["only_connect_to_start"]
+#      )
+#    end
+  end
+
+end