roby 0.8.0 → 3.0.0

data/lib/roby/test/expect_execution.rb

@@ -0,0 +1,151 @@
+module Roby
+    module Test
+        # Test related to execution in a Roby context
+        #
+        # This is the public interface of Roby's test swiss-army knife
+        # {#expect_execution}
+        #
+        # The block given to {#expect_execution} will be executed in Roby's
+        # event propagation context, and then some expectations can be matched
+        # against the result using the .to call:
+        #
+        #    expect_execution { ...code to be executed... }.
+        #       to { ... expectations ... }
+        #
+        # See the 'Expectations' section of {ExecutionExpectations} for an
+        # exhaustive list of existing expectations. Additional setup
+        # regarding the processing loop is documented in the Setup section
+        # of the same page, and can be used like this:
+        #
+        #    expect_execution { ...code to be executed... }.
+        #       timeout(10).
+        #       scheduler(true).
+        #       to { ... expectations ... }
+        #
+        # The execution expectation object is actually executed when one of
+        # the to_run or to { } methods is called. The former runs the block
+        # without any expectation (and therefore runs it only once, or until
+        # all async work is finished). The latter defines expectations and
+        # verifies them.
+        #
+        # @example emit an event and validate that it is emitted
+        #    plan.add(task = MyTask.new)
+        #    expect_execution { task.start! }.
+        #       to { emit task.start_event }
+        #
+        # Note that the heavy-lifting is done in {ExecutionExpectations}. This
+        # is really only the sugar-coating above the test harness itself.
+        module ExpectExecution
+            # The context object that allows the expect_execution { }.to { }
+            # syntax
+            Context = Struct.new :test, :expectations, :block do
+                SETUP_METHODS = [
+                    :timeout,
+                    :wait_until_timeout,
+                    :join_all_waiting_work,
+                    :scheduler,
+                    :garbage_collect,
+                    :validate_unexpected_errors,
+                    :display_exceptions]
+
+                def respond_to_missing?(m, include_private)
+                    SETUP_METHODS.include?(m)
+                end
+
+                def method_missing(m, *args)
+                    expectations.public_send(m, *args)
+                    self
+                end
+
+                # Run the block without any expectations
+                #
+                # Expectations might be added dynamically by the block given to
+                # expect_execution using {ExpectExecution#add_expectations}
+                def to_run
+                    to
+                end
+
+                # Declare the expectations and run
+                def to(&expectation_block)
+                    test.setup_current_expect_execution(self)
+                    if expectation_block
+                        expectations.parse(&expectation_block)
+                    end
+                    expectations.verify(&block)
+                rescue Minitest::Assertion => e
+                    raise e, e.message, caller(2)
+                ensure
+                    test.reset_current_expect_execution
+                end
+            end
+
+            # Exception raised when one of the method is called in a context
+            # that is not allowed
+            class InvalidContext < RuntimeError; end
+
+            # Declare expectations about the execution of a code block
+            #
+            # See the documentation of {ExpectExecution} for more details
+            #
+            # @raise [InvalidContext] if expect_execution is used from within an
+            #   expect_execution context, or within propagation context
+            def expect_execution(plan: self.plan, &block)
+                if plan.execution_engine.in_propagation_context?
+                    raise InvalidContext, "cannot recursively call #expect_execution"
+                end
+                expectations = ExecutionExpectations.new(self, plan)
+                Context.new(self, expectations, block)
+            end
+
+            # @api private
+            #
+            # Set the current expect_execution context. This is used to check
+            # for recursive calls to {#expect_execution}
+            def setup_current_expect_execution(context)
+                if @current_expect_execution
+                    raise InvalidContext, "cannot perform an expect_execution test within another one"
+                end
+                @current_expect_execution = context
+            end
+
+            # @api private
+            #
+            # Reset the current expect_execution block. This is used to check
+            # for recursive calls to {#expect_execution}
+            def reset_current_expect_execution
+                @current_expect_execution = nil
+            end
+
+            # Execute a block within the event propagation context
+            def execute(plan: self.plan, garbage_collect: false)
+                result = nil
+                expect_execution(plan: plan) { result = yield }.garbage_collect(garbage_collect).to_run
+                result
+            rescue Minitest::Assertion => e
+                raise e, e.message, caller(2)
+            end
+
+            # Run exactly once cycle
+            def execute_one_cycle(plan: self.plan, scheduler: false, garbage_collect: false)
+                expect_execution(plan: plan).
+                    join_all_waiting_work(false).
+                    scheduler(scheduler).
+                    garbage_collect(garbage_collect).
+                    to_run
+            end
+
+            # Add an expectation from within an execute { } or expect_execution
+            # { } block
+            #
+            # @raise [InvalidContext] if called outside of an
+            #   {#expect_execution} context
+            def add_expectations(&block)
+                if !@current_expect_execution
+                    raise InvalidContext, "#add_expectations not called within an expect_execution context"
+                end
+                @current_expect_execution.expectations.parse(ret: false, &block)
+            end
+        end
+    end
+end
+

data/lib/roby/test/minitest_helpers.rb

@@ -0,0 +1,166 @@
+require 'roby/test/expect_execution'
+
+module Roby
+    module Test
+        # Handlers for minitest-based tests
+        #
+        # They mainly "tune" the default minitest behaviour to match some of the
+        # Roby idioms as e.g. using pretty-print to format exception messages
+        module MinitestHelpers
+            include ExpectExecution
+
+            def roby_find_matching_exception(expected, exception)
+                queue = [exception]
+                seen  = Set.new
+                while !queue.empty?
+                    e = queue.shift
+                    next if seen.include?(e)
+                    seen << e
+                    if expected.any? { |expected_e| e.kind_of?(expected_e) }
+                        return e
+                    end
+                    if e.respond_to?(:original_exceptions)
+                        queue.concat(e.original_exceptions)
+                    end
+                end
+                nil
+            end
+
+            def assert_raises(*exp, display_exceptions: false, return_original_exception: false, &block)
+                if plan.executable?
+                    # Avoid having it displayed by the execution engine. We're going
+                    # to display any unexpected exception anyways
+                    display_exceptions_enabled, plan.execution_engine.display_exceptions =
+                        plan.execution_engine.display_exceptions?, display_exceptions
+                end
+
+                msg = exp.pop if String === exp.last
+
+                matchers = exp.dup
+                exp = exp.map do |e|
+                    if e.kind_of?(Queries::LocalizedErrorMatcher)
+                        e.model
+                    else
+                        e
+                    end
+                end
+
+                # The caller expects a non-Roby exception. It is going to be
+                # wrapped in a LocalizedError, so make sure we properly
+                # process it
+                begin
+                    yield
+                rescue *exp => e
+                    if matchers.any? { |m| m === e }
+                        assert_exception_can_be_pretty_printed(e)
+                        return e
+                    else
+                        flunk("#{matchers.map(&:to_s).join(", ")} exceptions expected, not #{e.class}")
+                    end
+                rescue ::Exception => root_e
+                    assert_exception_can_be_pretty_printed(root_e)
+                    all = Roby.flatten_exception(root_e)
+                    if actual_e = all.find { |e| matchers.any? { |expected_e| expected_e === e } }
+                        if return_original_exception
+                            return actual_e, root_e
+                        else
+                            return actual_e
+                        end
+                    end
+                    actually_caught = roby_exception_to_string(*all)
+                    flunk("#{exp.map(&:to_s).join(", ")} exceptions expected, not #{root_e.class} #{actually_caught}")
+                end
+                flunk("#{exp.map(&:to_s).join(", ")} exceptions expected but received nothing")
+
+            ensure
+                if plan.executable?
+                    plan.execution_engine.display_exceptions =
+                        display_exceptions_enabled
+                end
+            end
+
+            def roby_exception_to_string(*queue)
+                msg = ""
+                seen = Set.new
+                while e = queue.shift
+                    next if seen.include?(e)
+                    seen << e
+                    e_bt = Minitest.filter_backtrace(e.backtrace).join "\n    "
+                    msg << "\n\n" << Roby.format_exception(e).join("\n") +
+                        "\n    #{e_bt}"
+
+                    queue.concat(e.original_exceptions) if e.respond_to?(:original_exceptions)
+                end
+                msg
+            end
+
+            def to_s
+                if !error?
+                    super
+                else
+                    failures.map { |failure|
+                        bt = Minitest.filter_backtrace(failure.backtrace).join "\n    "
+                        msg = 
+                            if failure.kind_of?(Minitest::UnexpectedError)
+                                roby_exception_to_string(failure.exception)
+                            else
+                                failure.message
+                            end
+                        "#{failure.result_label}:\n#{self.location}:\n#{msg}\n"
+                    }.join "\n"
+                end
+            end
+
+            def register_failure(e)
+                case e
+                when Assertion
+                    self.failures << e
+                else
+                    self.failures << Minitest::UnexpectedError.new(e)
+                end
+            end
+
+            def capture_exceptions
+                super do
+                    begin
+                        yield
+                    rescue Exception => root_e
+                        if !root_e.respond_to?(:each_original_exception)
+                            raise
+                        end
+
+                        exceptions = root_e.each_original_exception
+                        register_failure(root_e)
+
+                        # Try to be smart and to only keep the toplevel
+                        # exceptions
+                        filter_execution_exceptions(exceptions).each do |e|
+                            if !e.backtrace
+                                e.set_backtrace(root_e.backtrace)
+                            end
+                            register_failure(e)
+                        end
+                    end
+                end
+            end
+
+            def filter_execution_exceptions(exceptions)
+                exceptions.flat_map { |e| Roby.flatten_exception(e).to_a }.uniq
+            end
+
+            def exception_details e, msg
+                [
+                    "#{msg}",
+                    "Class: <#{e.class}>",
+                    "Message: <#{e.message.inspect}>",
+                    "Pretty-print:",
+                    *Roby.format_exception(e),
+                    "---Backtrace---",
+                    "#{Minitest.filter_backtrace(e.backtrace).join("\n")}",
+                    "---------------",
+                ].join "\n"
+            end
+        end
+    end
+end
+

data/lib/roby/test/roby_app_helpers.rb

@@ -0,0 +1,200 @@
+module Roby
+    module Test
+        # Helpers to test a full Roby app started as a subprocess
+        module RobyAppHelpers
+            attr_reader :app, :app_dir
+
+            def setup
+                @spawned_pids = Array.new
+                super
+                @app = Roby::Application.new
+                app.public_logs = false
+                app.plugins_enabled = false
+                @app_dir = make_tmpdir
+                app.app_dir = app_dir
+                register_plan(@app.plan)
+            end
+
+            def teardown
+                super
+                app.stop_log_server
+                app.stop_shell_interface
+                app.cleanup
+                pending_children = @spawned_pids.find_all do |pid|
+                    begin
+                        Process.kill 'INT', pid
+                        true
+                    rescue Errno::ESRCH
+                    end
+                end
+
+                pending_children.each do |pid|
+                    Process.waitpid2(pid)
+                end
+            end
+
+            def gen_app(app_dir = self.app_dir)
+                require 'roby/cli/gen_main'
+                Dir.chdir(app_dir) { CLI::GenMain.start(['app', '--quiet']) }
+            end
+
+            def roby_bin
+                File.expand_path(
+                    File.join("..", "..", "..", 'bin', 'roby'),
+                    __dir__)
+            end
+
+            def roby_app_with_polling(timeout: 2, period: 0.01, message: nil)
+                start_time = Time.now
+                while (Time.now - start_time) < timeout
+                    if result = yield
+                        return result
+                    end
+                    sleep 0.01
+                end
+                if message
+                    flunk "#{message} did not happen within #{timeout} seconds"
+                else
+                    flunk "failed to reach expected result within #{timeout} seconds"
+                end
+            end
+
+            def assert_roby_app_is_running(pid, timeout: 10, host: 'localhost', port: Roby::Interface::DEFAULT_PORT)
+                start_time = Time.now
+                while (Time.now - start_time) < timeout
+                    if ::Process.waitpid(pid, Process::WNOHANG)
+                        flunk "Roby app unexpectedly quit"
+                    end
+
+                    begin
+                        return Roby::Interface.connect_with_tcp_to(host, port)
+                    rescue Roby::Interface::ConnectionError
+                    end
+                    sleep 0.01
+                end
+                flunk "could not get a connection within #{timeout} seconds"
+            end
+
+            def assert_roby_app_quits(pid, interface: nil)
+                interface ||= assert_roby_app_is_running(pid)
+                interface.quit
+                _, status = Process.waitpid2(pid)
+                assert status.exited?
+                assert_equal 0, status.exitstatus
+            end
+
+            def assert_roby_app_has_job(interface, action_name, timeout: 2, state: Interface::JOB_STARTED)
+                start_time = Time.now
+                while (Time.now - start_time) < timeout
+                    jobs = interface.find_all_jobs_by_action_name(action_name)
+                    if state
+                        jobs = jobs.find_all { |j| j.state == state }
+                    end
+                    if j = jobs.first
+                        return j
+                    end
+                    sleep 0.01
+                end
+                flunk "timed out while waiting for action #{action_name} on #{interface}"
+            end
+
+            def roby_app_quit(interface, timeout: 2)
+                _, status = Process.waitpid2(pid)
+                if !status.success?
+                    raise "roby app with PID #{pid} exited with nonzero status"
+                end
+            end
+
+            def roby_app_fixture_path
+                File.expand_path(
+                    File.join("..", "..", "..", 'test', "app", "fixtures"),
+                    __dir__)
+            end
+
+            def roby_app_setup_single_script(*scripts)
+                dir = make_tmpdir
+                FileUtils.mkdir_p File.join(dir, 'config', 'robots')
+                FileUtils.mkdir_p File.join(dir, 'scripts')
+                FileUtils.touch File.join(dir, 'config', 'app.yml')
+                FileUtils.touch File.join(dir, 'config', 'robots', 'default.rb')
+                scripts.each do |p|
+                    p = File.expand_path(p, roby_app_fixture_path)
+                    FileUtils.cp p, File.join(dir, 'scripts')
+                end
+                return dir
+            end
+
+            def roby_app_spawn(*args, silent: false, **options)
+                if silent
+                    options[:out] ||= '/dev/null'
+                    options[:err] ||= '/dev/null'
+                end
+                pid = spawn(roby_bin, *args, chdir: app_dir, **options)
+                @spawned_pids << pid
+                return pid
+            end
+
+            def roby_app_create_logfile
+                require 'roby/droby/logfile/writer'
+                logfile_dir = make_tmpdir
+                logfile_path = File.join(logfile_dir, 'logfile')
+                writer = DRoby::Logfile::Writer.open(logfile_path)
+                return logfile_path, writer
+            end
+
+            def roby_app_call_interface(host: 'localhost', port: Interface::DEFAULT_PORT)
+                client_thread = Thread.new do
+                    begin
+                        interface = Interface.connect_with_tcp_to(host, port)
+                        if block_given?
+                            result = yield(interface)
+                        end
+                    rescue Exception => e
+                        error = e
+                    end
+                    [interface, result, error]
+                end
+                while client_thread.alive?
+                    app.shell_interface.process_pending_requests
+                end
+                begin 
+                    interface, result, error = client_thread.value
+                rescue Exception => e
+                    raise e, e.message, e.backtrace + caller
+                end
+                interface.close
+                raise error if error
+                result
+            end
+
+            def assert_roby_app_can_connect_to_log_server(timeout: 2, port: app.log_server_port)
+                client = roby_app_with_polling(timeout: timeout, message: "connecting to the log server on port #{port}") do
+                    begin DRoby::Logfile::Client.new('localhost', port)
+                    rescue Interface::ConnectionError
+                    end
+                end
+                while !client.init_done?
+                    client.read_and_process_pending
+                end
+            rescue Exception
+                # Give time to the log server to report errors before we
+                # terminate it with SIGINT
+                sleep 0.1
+                raise
+            ensure
+                client.close if client
+            end
+
+            def app_helpers_source_dir(source_dir)
+                @helpers_source_dir = source_dir
+            end
+
+            def copy_into_app(template, target = template)
+                FileUtils.mkdir_p File.join(app_dir, File.dirname(target))
+                FileUtils.cp File.join(@helpers_source_dir, template),
+                    File.join(app_dir, target)
+            end
+        end
+    end
+end
+