roby 0.8.0 → 3.0.0

data/lib/roby/test/run_planners.rb

@@ -0,0 +1,155 @@
+module Roby
+    module Test
+        module RunPlanners
+            # @api private
+            #
+            # Helper that sets up the planning handlers for {#run_planners}
+            def self.setup_planning_handlers(plan, root_task, recursive: true)
+                if root_task.respond_to?(:as_plan)
+                    root_task = root_task.as_plan
+                    plan.add(root_task)
+                end
+
+                if recursive
+                    tasks = plan.task_relation_graph_for(Roby::TaskStructure::Dependency).
+                        enum_for(:depth_first_visit, root_task).to_a
+                else
+                    tasks = [root_task]
+                end
+
+                by_handler = tasks.find_all { |t| t.abstract? && t.planning_task }.
+                    group_by { |t| RunPlanners.planner_handler_for(t) }.
+                    map { |handler_class, tasks| [handler_class.new, tasks] }
+                return root_task.as_service, Array.new if by_handler.empty?
+
+                placeholder_tasks = Hash.new
+                by_handler.each do |handler, tasks|
+                    tasks.each do |t|
+                        placeholder_tasks[t] = t.as_service
+                    end
+                    handler.start(tasks)
+                end
+
+                return (placeholder_tasks[root_task] || root_task.as_service), by_handler
+            end
+
+            # Run the planners that are required by a task or subplan
+            #
+            # @param [Task] root_task the task whose planners we want to run, or
+            #   the root of the subplan
+            # @param [Boolean] recursive whether the method attempts to run the
+            #   planners recursively in both plan (considering the whole subplan
+            #   of root_task) and time (re-run planners for tasks if existing
+            #   planning tasks generate subplans containing planning tasks
+            #   themselves)
+            def run_planners(root_task, recursive: true)
+                if !execution_engine.in_propagation_context?
+                    service = nil
+                    expect_execution { service = run_planners(root_task, recursive: recursive) }.
+                        to_run
+                    if service
+                        return service.to_task
+                    else return
+                    end
+                end
+
+                root_task_service, by_handler = RunPlanners.setup_planning_handlers(plan, root_task, recursive: recursive)
+                return root_task_service if by_handler.empty?
+
+                add_expectations do
+                    achieve(description: "expected all planning handlers to finish") do
+                        if by_handler && !by_handler.empty? && by_handler.all? { |handler, tasks| handler.finished? }
+                            if recursive
+                                by_handler = nil
+                                execute do
+                                    new_root = root_task_service.to_task
+                                    root_task_service, by_handler = RunPlanners.setup_planning_handlers(plan, new_root, recursive: true)
+                                end
+                            else
+                                by_handler = Array.new
+                            end
+                        end
+
+                        # by_handler == nil is used to indicate that an execute
+                        # block is pending
+                        by_handler && by_handler.empty?
+                    end
+                end
+                return root_task_service
+            end
+
+            # Interface for a planning handler for {#roby_run_planner}
+            #
+            # This class is only used to describe the required interface. See
+            # {ActionPlanningHandler} for an example
+            class PlanningHandler
+                # Start planning these tasks
+                #
+                # This is called within a propagation context
+                def start(tasks)
+                    raise NotImplementedError
+                end
+
+                # Whether planning is finished for the given tasks
+                #
+                # This is called within a propagation context
+                def finished?
+                    raise NotImplementedError
+                end
+            end
+
+            @@roby_planner_handlers = Array.new
+
+            # @api private
+            #
+            # Find the handler that should be used by {#roby_run_planner} to
+            # plan a given task.
+            #
+            # @param [Task] task
+            # @return [PlanningHandler]
+            # @raise ArgumentError
+            def self.planner_handler_for(task)
+                _, handler_class = @@roby_planner_handlers.find { |matcher, handler| matcher === task }
+                if handler_class
+                    handler_class
+                else
+                    raise ArgumentError, "no planning handler found for #{task}"
+                end
+            end
+
+            # Declare what {#roby_run_planner} should use to develop a given
+            # task during a test
+            #
+            # The latest handler registered wins
+            #
+            # @param [PlanningHandler] a planning handler
+            def self.roby_plan_with(matcher, handler)
+                @@roby_planner_handlers.unshift [matcher, handler]
+            end
+
+
+            # Planning handler for {#roby_run_planner} that handles roby action tasks
+            class ActionPlanningHandler
+                # (see PlanningHandler#start)
+                def start(tasks)
+                    @planning_tasks = tasks.map do |planned_task|
+                        planning_task = planned_task.planning_task
+                        execution_engine = planning_task.execution_engine
+                        if !execution_engine.scheduler.enabled?
+                            planning_task.start!
+                        end
+                        planning_task
+                    end
+                end
+                
+                # (see PlanningHandler#finished?)
+                def finished?
+                    @planning_tasks.all?(&:success?)
+                end
+            end
+            roby_plan_with Roby::Task.match.with_child(Roby::Actions::Task), ActionPlanningHandler
+        end
+    end
+end
+
+

data/lib/roby/test/self.rb

@@ -0,0 +1,112 @@
+
+# simplecov must be loaded FIRST. Only the files required after it gets loaded
+# will be profiled !!!
+if ENV['TEST_ENABLE_COVERAGE'] == '1' || ENV['TEST_COVERAGE_MODE']
+    mode = ENV['TEST_COVERAGE_MODE'] || 'simplecov'
+    begin
+        require mode
+    rescue LoadError => e
+        require 'roby'
+        Roby.warn "coverage is disabled because the code coverage gem cannot be loaded: #{e.message}"
+    rescue Exception => e
+        require 'roby'
+        Roby.warn "coverage is disabled: #{e.message}"
+    end
+end
+
+require 'minitest/autorun'
+require 'flexmock/minitest'
+require 'roby'
+require 'roby/test/common'
+require 'roby/test/event_reporter'
+require 'roby/test/minitest_helpers'
+require 'roby/test/run_planners'
+require 'roby/tasks/simple'
+require 'roby/test/tasks/empty_task'
+
+module Roby
+    module Test
+    # This module is extending Test to be able to run tests using the normal
+    # testrb command. It is meant to be used to test libraries (e.g. Roby
+    # itself) as, in complex Roby applications, the setup and teardown steps
+    # would be very expensive.
+    #
+    # @see Test
+    module Self
+        include Roby::Test
+        include Roby::Test::Assertions
+        include Test::RunPlanners
+
+        def setup
+            @temp_dirs = Array.new
+
+            Roby.app.log['server'] = false
+            Roby.app.auto_load_models = false
+            Roby.app.plugins_enabled = false
+            Roby.app.testing = true
+            Roby.app.public_logs = false
+            Roby.app.log_base_dir = make_tmpdir
+            Roby.app.reset_log_dir
+            Roby.app.setup
+            Roby.app.prepare
+
+            @plan    = ExecutablePlan.new(event_logger: EventReporter.new(STDOUT))
+            @control = DecisionControl.new
+
+            super
+
+            # Save and restore some arrays
+            save_collection Roby::ExecutionEngine.propagation_handlers
+            save_collection Roby::ExecutionEngine.external_events_handlers
+            save_collection Roby::Plan.structure_checks
+            Roby.app.abort_on_exception = false
+            Roby.app.abort_on_application_exception = true
+        end
+
+        def enable_event_reporting(*filters)
+            plan.event_logger.enabled = true
+            filters.each { |f| plan.event_logger.filter(f) }
+        end
+
+        def teardown
+            @temp_dirs.each { |p| FileUtils.rm_rf(p) }
+            begin
+                super
+            rescue Exception => e
+                teardown_failure = e
+            end
+            if execution_engine
+                execution_engine.shutdown
+            end
+            Roby.app.shutdown
+            Roby.app.cleanup
+            State.clear
+            State.clear_model
+            Conf.clear
+            Conf.clear_model
+
+        ensure
+            if teardown_failure
+                raise teardown_failure
+            end
+        end
+
+        def make_tmpdir
+            @temp_dirs << (dir = Dir.mktmpdir)
+            dir
+        end
+    end
+    end
+    SelfTest = Test::Self
+end
+
+FlexMock.partials_are_based = true
+FlexMock.partials_verify_signatures = true
+
+module Minitest
+    class Test
+        include Roby::Test::Self
+        prepend Roby::Test::MinitestHelpers
+    end
+end
+

data/lib/roby/test/spec.rb

@@ -0,0 +1,198 @@
+require 'utilrb/timepoints'
+require 'roby/test/error'
+require 'roby/test/common'
+require 'roby/test/dsl'
+require 'roby/test/teardown_plans'
+require 'roby/test/minitest_helpers'
+require 'roby/test/run_planners'
+require 'timecop'
+
+FlexMock.partials_are_based = true
+FlexMock.partials_verify_signatures = true
+
+module Roby
+    module Test
+        class Spec < Minitest::Spec
+            include Test::Assertions
+            include Test::TeardownPlans
+            include Test::MinitestHelpers
+            include Test::RunPlanners
+            include Utilrb::Timepoints
+            extend DSL
+
+            def app
+                Roby.app
+            end
+            def plan
+                app.plan
+            end
+            def engine
+                Roby.warn_deprecated "#engine is deprecated, use #execution_engine instead"
+                execution_engine
+            end
+            def execution_engine
+                app.execution_engine
+            end
+
+            def self.test_methods
+                methods = super
+                # Duplicate each method 'repeat' times
+                methods.inject([]) do |list, m|
+                    list.concat([m] * Roby.app.test_repeat)
+                end
+            end
+
+            def __full_name__
+                "#{self.class}##{name}"
+            end
+
+            # Set of models present during {#setup}
+            #
+            # This is used to clear all the models created during the test in
+            # {#teardown}
+            attr_reader :models_present_in_setup
+
+            def setup
+                plan.execution_engine.display_exceptions = false
+                # Mark every app-defined model as permanent, so that the tests can define
+                # their own and get cleanup up properly on teardown
+                @models_present_in_setup = Set.new
+                app.root_models.each do |root_model|
+                    models_present_in_setup << root_model
+                    root_model.each_submodel do |m|
+                        models_present_in_setup << m
+                    end
+                end
+                register_plan(plan)
+
+                super
+            end
+
+            def teardown
+                Timecop.return
+
+                begin
+                    super
+                rescue ::Exception => e
+                    teardown_failure = e
+                end
+
+                teardown_registered_plans
+
+            ensure
+                clear_registered_plans
+                if teardown_failure
+                    raise teardown_failure
+                end
+            end
+
+            def clear_newly_defined_models
+                app.root_models.each do |root_model|
+                    ([root_model] + root_model.each_submodel.to_a).each do |m|
+                        if !models_present_in_setup.include?(m)
+                            m.permanent_model = false
+                            m.clear_model
+                        end
+                    end
+                end
+            end
+
+            def process_events(timeout: 10, **options, &caller_block)
+                Roby.warn_deprecated "do not use #process_events. Use the expect_execution infrastructure instead"
+
+                exceptions = Array.new
+                first_pass = true
+                while first_pass || execution_engine.has_waiting_work?
+                    first_pass = false
+
+                    execution_engine.join_all_waiting_work(timeout: timeout)
+                    execution_engine.start_new_cycle
+                    errors = execution_engine.process_events(**options, &caller_block)
+                    caller_block = nil
+                    exceptions.concat(errors.exceptions)
+                    execution_engine.cycle_end(Hash.new)
+                end
+
+                if !exceptions.empty?
+                    if exceptions.size == 1
+                        raise exceptions.first.exception
+                    else
+                        raise SynchronousEventProcessingMultipleErrors.new(exceptions.map(&:exception))
+                    end
+                end
+            end
+
+            # Repeatedly process events until a condition is met
+            #
+            # @yieldreturn [Boolean] true if the condition is met, false otherwise
+            def process_events_until(timeout: 5, **options)
+                Roby.warn_deprecated "do not use #process_events. Use the expect_execution infrastructure with the 'achieve' expectation instead"
+
+                start = Time.now
+                while !yield
+                    now = Time.now
+                    remaining = timeout - (now - start)
+                    if remaining < 0
+                        flunk("failed to reach expected condition within #{timeout} seconds")
+                    end
+                    process_events(timeout: remaining, **options)
+                    sleep 0.01
+                end
+            end
+
+            # @deprecated use capture_log instead
+            def inhibit_fatal_messages(&block)
+                Roby.warn_deprecated "#{__method__} is deprecated, use capture_log instead"
+                with_log_level(Roby, Logger::FATAL, &block)
+            end
+
+            # @deprecated use capture_log instead
+            def with_log_level(log_object, level)
+                Roby.warn_deprecated "#{__method__} is deprecated, use capture_log instead"
+                if log_object.respond_to?(:logger)
+                    log_object = log_object.logger
+                end
+                current_level = log_object.level
+                log_object.level = level
+
+                yield
+
+            ensure
+                if current_level
+                    log_object.level = current_level
+                end
+            end
+
+            # @deprecated use {#run_planners} instead
+            def roby_run_planner(root_task, recursive: true, **options)
+                run_planners(root_task, recursive: true, **options)
+            end
+
+            # Declare what {#roby_run_planner} should use to develop a given
+            # task during a test
+            #
+            # The latest handler registered wins
+            #
+            # @param [PlanningHandler] a planning handler
+            def self.roby_plan_with(matcher, handler)
+                RunPlanners.roby_plan_with(matcher, handler)
+            end
+
+            # Filters out the test suites that are not enabled by the current
+            # Roby configuration
+            def run
+                time_it do
+                    capture_exceptions do
+                        self.class.roby_should_run(self, app)
+                        super
+                    end
+                end
+            end
+        end
+    end
+
+    Minitest::Spec.register_spec_type Roby::Test::Spec do |desc|
+        desc.kind_of?(Class) && (desc <= Roby::Task)
+    end
+end
+