roby 0.8.0 → 3.0.0

data/lib/roby/app/scripts/test.rb

@@ -1,40 +1,125 @@
 require 'roby'
+require 'roby/test/spec'
 require 'optparse'
 
+Robot.logger.level = Logger::WARN
+
+app = Roby.app
+app.require_app_dir
+app.public_logs = false
+app.single = true
+app.simulation = true
+app.testing = true
+app.auto_load_models = false
+
+MetaRuby.keep_definition_location = false
+
+list_tests = false
+coverage_mode = false
+only_self = false
+all = true
 testrb_args = []
+excluded_patterns = []
 parser = OptionParser.new do |opt|
-    opt.on("-s", "--sim", "run tests in simulation mode") do |val|
-	Roby.app.simulation = val
+    opt.banner = "#{File.basename($0)} test [ROBY_OPTIONS] -- [MINITEST_OPTIONS] [TEST_FILES]"
+    opt.on('--self', 'only run tests that are present in this bundle') do |val|
+        only_self = true
     end
-    opt.on("-k", "--keep-logs", "keep all logs") do |val|
-	Roby.app.testing_keep_logs = val
+    opt.on('--not-all', 'run all the tests found in the bundle, regardless of whether they are loaded by the robot configuration') do |val|
+        all = false
+    end
+    opt.on('--really-all', 'load all models, and run all the tests found in the bundle') do |val|
+        app.auto_load_models = true
+        all = true
     end
-    opt.on("-o", "--overwrite-oldlogs", "if there are logs for the same test case, overwrite them") do |val|
-	Roby.app.testing_overwrites_logs = val
+
+    opt.on('--exclude PATTERN', String, 'do not run files matching this pattern') do |pattern|
+        excluded_patterns << File.expand_path(pattern, Roby.app.app_dir)
+    end
+    opt.on("--distributed", "access remote systems while setting up or running the tests") do |val|
+        Roby.app.single = !val
+    end
+    opt.on('--list', 'lists the test files that are executed, but does not execute them') do
+        list_tests = true
+    end
+    opt.on("-l", "--live", "run tests in live mode") do |val|
+        Roby.app.simulation = !val
+    end
+    opt.on("-k", "--keep-logs", "keep all logs") do |val|
+        Roby.app.public_logs = true
     end
     opt.on("-i", "--interactive", "allow user interaction during tests") do |val|
-	Roby.app.automatic_testing = false
+        Roby.app.automatic_testing = false
     end
-    opt.on("-n", "--name NAME", String, "run tests matching NAME") do |name|
-	testrb_args << "-n" << name
+    opt.on("--coverage", "generate code coverage information. This autoloads all files and task context models to get a full coverage information") do |name|
+        coverage_mode = true
     end
+    opt.on '--help' do
+        pp opt
+        Minitest.run ['--help']
+        exit 0
+    end
+    Roby::Application.common_optparse_setup(opt)
 end
-parser.parse! ARGV
-Roby.app.testing = true
-require 'roby/test/testcase'
 
-app = Roby.app
-app.setup
+test_files = parser.parse(ARGV)
+test_files.delete_if do |arg|
+    if arg.start_with?('-')
+        testrb_args << arg
+        true
+    end
+end
 
-r = Test::Unit::AutoRunner.new(true)
-r.process_args(ARGV + testrb_args) or
-  abort r.options.banner + " tests..."
+if test_files.empty?
+    MetaRuby.keep_definition_location = true
+end
 
-if r.filters.empty?
-    r.filters << lambda do |t|
-	t.class != Roby::Test::TestCase
-    end
+if coverage_mode
+    require 'simplecov'
+    SimpleCov.start
 end
 
-exit r.run
+exception = Roby.display_exception do
+    Roby.app.setup
+    if Roby.app.public_logs?
+        STDOUT.puts "Test logs are saved in #{Roby.app.log_dir}"
+    end
+    begin
+        Roby.app.prepare
+
+        if test_files.empty?
+            test_files = app.discover_test_files(all: all, only_self: only_self).map(&:first)
+            self_files, dependent_files = test_files.partition { |f| app.self_file?(f) }
+            test_files = self_files.sort + dependent_files.sort
+            if list_tests
+                puts "Would load #{test_files.size} test files"
+                test_files.each do |path|
+                    puts "  #{path}"
+                end
+
+                all_existing_tests = app.find_dirs('test', order: :specific_first, all: !only_self).inject(Set.new) do |all, dir|
+                    all.merge(Find.enum_for(:find, dir).find_all { |f| f =~ /\/test_.*\.rb$/ && File.file?(f) }.to_set)
+                end
+                not_run = (all_existing_tests - test_files.to_set)
+                if !not_run.empty?
+                    puts "\nWould NOT load #{not_run.size} tests"
+                    not_run.to_a.sort.each do |not_loaded|
+                        puts "  #{not_loaded}"
+                    end
+                end
+                exit 0
+            end
+        end
 
+        test_files.each do |arg|
+            next if excluded_patterns.any? { |pattern| File.fnmatch?(pattern, arg) }
+            require arg
+        end
+        passed = Minitest.run(testrb_args)
+        exit(1) unless passed
+    ensure
+        Roby.app.shutdown
+        Roby.app.cleanup
+    end
+end
+exit(exception ? 1 : 0)

data/lib/roby/app/test_reporter.rb

@@ -0,0 +1,74 @@
+require 'roby/app/test_server'
+
+module Roby
+    module App
+        # Minitest reporter for a client/server scheme in autotest
+        #
+        # Note that the idea and a big chunk of the implementation has been
+        # taken from the minitest-server plugin. The main differences is that it
+        # accounts for load errors (exceptions that happen outside of minitest
+        # itself) and is using DRoby's marshalling for exceptions
+        class TestReporter
+            attr_reader :pid
+            attr_reader :slave_name
+            attr_reader :server
+            attr_reader :manager
+
+            # Whether some failures were reported
+            attr_predicate :has_failures?
+
+            def initialize(pid, slave_name, server_pid, manager: DRoby::Marshal.new)
+                @pid = pid
+                @slave_name = slave_name
+                uri = TestServer.path(server_pid)
+                @server = DRbObject.new_with_uri uri
+                @manager = manager
+                super()
+            end
+
+            def exception(e)
+                @has_failures = true
+                server.exception(pid, manager.dump(e))
+            end
+
+            def discovery_start
+                server.discovery_start(pid)
+            end
+
+            def discovery_finished
+                server.discovery_finished(pid)
+            end
+
+            def test_start
+                server.test_start(pid)
+            end
+
+            # This method is part of the minitest API
+            def prerecord(klass, method_name)
+                file, = klass.instance_method(method_name).source_location
+                server.test_method(pid, file, klass.name, method_name)
+            end
+
+            # This method is part of the minitest API ... cannot change its name
+            def record(result)
+                r = result
+                if r.respond_to?(:source_location) # Minitest 3.11+
+                    class_name = r.klass
+                    file, = r.source_location
+                else
+                    c = r.class
+                    file, = c.instance_method(r.name).source_location
+                    class_name = c.name
+                end
+                failures = manager.dump(r.failures)
+                @has_failures ||= r.failures.any? { |e| !e.kind_of?(Minitest::Skip) }
+                server.test_result(pid, file, class_name, r.name, failures, r.assertions, r.time)
+            end
+
+            def test_finished
+                server.test_finished(pid)
+            end
+        end
+    end
+end
+

data/lib/roby/app/test_server.rb

@@ -0,0 +1,159 @@
+require 'minitest'
+require "drb"
+require "tmpdir"
+require 'roby/hooks'
+require 'roby/droby'
+
+module Roby
+    module App
+        class Minitest::UnexpectedError
+            def droby_dump(peer = nil)
+                result = dup
+                result.exception = exception.droby_dump(peer)
+                result
+            end
+
+            def proxy(manager)
+                result = dup
+                result.exception = manager.local_object(result.exception)
+                result
+            end
+
+            def pretty_print(pp)
+                exception.pretty_print(pp)
+            end
+        end
+
+        # DRuby server for a client/server scheme in autotest
+        #
+        # The client side is implemented in {TestReporter}
+        #
+        # Note that the idea and a big chunk of the implementation has been
+        # taken from the minitest-server plugin. The main differences is that it
+        # accounts for load errors (exceptions that happen outside of minitest
+        # itself) and is using DRoby's marshalling for exceptions
+        class TestServer
+            def self.path(pid = Process.pid)
+                "drbunix:#{Dir.tmpdir}/minitest.#{pid}"
+            end
+
+            include Hooks
+            include Hooks::InstanceHooks
+
+            # @!method on_exception
+            #
+            # Hook called when an exception has been caught by Autorespawn
+            #
+            # @yieldparam [Integer] pid the client PID
+            # @yieldparam [Exception] exception
+            define_hooks :on_exception
+
+            # @!method on_discovery_start
+            #
+            # Hook called when a discovery process starts
+            #
+            # @yieldparam [Integer] pid the client PID
+            define_hooks :on_discovery_start
+
+            # @!method on_discovery_finished
+            #
+            # Hook called when a discovery process finishes
+            #
+            # @yieldparam [Integer] pid the client PID
+            # @yieldparam [Hash] id the test ID
+            define_hooks :on_discovery_finished
+
+            # @!method on_test_start
+            #
+            # Hook called when a test starts
+            #
+            # @yieldparam [Integer] pid the client PID
+            define_hooks :on_test_start
+
+            # @!method on_test_method
+            #
+            # Hook called when a test method starts its execution
+            #
+            # @yieldparam [Integer] pid the client PID
+            # @yieldparam [String] file the file containing the test
+            # @yieldparam [String] test_case_name the test case name
+            # @yieldparam [String] test_name the test name
+            define_hooks :on_test_method
+
+            # @!method on_test_result
+            #
+            # Hook called when a test has been executed
+            #
+            # @yieldparam [Integer] pid the client PID
+            # @yieldparam [String] file the file containing the test
+            # @yieldparam [String] test_case_name the test case name
+            # @yieldparam [String] test_name the test name
+            # @yieldparam [Array<Minitest::Assertion>] failures the list of test failures
+            # @yieldparam [Integer] assertions the number of assertions
+            # @yieldparam [Time] time the time spent running the test
+            define_hooks :on_test_result
+
+            # @!method on_test_finished
+            #
+            # Hook called when a test finished
+            #
+            # @yieldparam [Integer] pid the client PID
+            define_hooks :on_test_finished
+
+            # A value that allows to identify this server uniquely
+            #
+            # Usually the server PID
+            attr_reader :server_id
+
+            # The autorespawn manager
+            #
+            # @return [Autorespawn::Manager]
+            attr_reader :manager
+
+            def self.start(id)
+                server = new(id)
+                DRb.start_service path, server
+                server
+            end
+
+            def self.stop
+                DRb.stop_service
+            end
+
+            def initialize(server_id, manager = DRoby::Marshal.new(auto_create_plans: true))
+                @server_id = server_id
+                @manager = manager
+            end
+
+            def discovery_start(pid)
+                run_hook :on_discovery_start, pid
+            end
+
+            def discovery_finished(pid)
+                run_hook :on_discovery_finished, pid
+            end
+
+            def exception(pid, e)
+                run_hook :on_exception, pid, manager.local_object(e)
+            end
+
+            def test_start(pid)
+                run_hook :on_test_start, pid
+            end
+
+            def test_method(pid, file, klass, method)
+                run_hook :on_test_method, pid, file, klass, method
+            end
+
+            def test_result(pid, file, klass, method, fails, assertions, time)
+                run_hook :on_test_result, pid, file, klass, method,
+                    manager.local_object(fails), assertions, time
+            end
+
+            def test_finished(pid)
+                run_hook :on_test_finished, pid
+            end
+        end
+    end
+end
+

data/lib/roby/app/vagrant.rb

@@ -0,0 +1,47 @@
+module Roby
+    module App
+        # Utilities related to Vagrant VMs
+        module Vagrant
+            # Exception thrown when trying to resolve a vagrant VM and it is not
+            # running
+            class NotRunning < ArgumentError; end
+
+            # Exception raise when trying to resolve a vagrant VM but cannot find it
+            class NotFound < ArgumentError; end
+
+            # Exception raised when a vagrant VM could be found, but its IP cannot
+            # be resolved through 'vagrant ssh-config'
+            class CannotResolveHostname < ArgumentError; end
+
+            # Resolves the global ID of a vagrant VM
+            #
+            # @param [String] vagrant_name the name or ID of the vagrant VM
+            # @raise VagrantVMNotFound
+            # @raise VagrantVMNotRunning
+            def self.resolve_vm(vagrant_name)
+                IO.popen(['vagrant', 'global-status']).each_line do |line|
+                    id, name, provider, state, * = line.chomp.split(/\s+/)
+                    if vagrant_name == id || vagrant_name == name
+                        if state != 'running'
+                            raise NotRunning, "cannot connect to vagrant VM #{vagrant_name}: in state #{state} (requires running)"
+                        end
+                        return id
+                    end
+                end
+                raise NotFound, "cannot find a vagrant VM called #{vagrant_name}, run vagrant global-status to check vagrant's status"
+            end
+
+            # Resolve the IP of a vagrant VM
+            def self.resolve_ip(vagrant_name)
+                id = resolve_vm(vagrant_name)
+                IO.popen(['vagrant', 'ssh-config', id]).each_line do |line|
+                    if line =~ /HostName (.*)/
+                        return $1.strip
+                    end
+                end
+                raise CannotResolveHostname, "did not find a Hostname in the ssh-config of vagrant VM #{vagrant_name} (with id #{id}). Check the result of vagrant ssh-config #{id}"
+            end
+        end
+    end
+end
+

data/lib/roby/backports.rb

@@ -0,0 +1,16 @@
+# List of backports waiting to be accepted in the backports gem
+class Set
+    # Defined in 2.4.0
+    #
+    # Hash#compare_by_identity appeared in ruby 1.9.1
+    def compare_by_identity
+        @hash.compare_by_identity
+    end
+
+    # Defined in 2.4.0
+    #
+    # Hash#compare_by_identity? appeard in ruby 1.9.1
+    def compare_by_identity?
+        @hash.compare_by_identity?
+    end
+end

data/lib/roby/cli/display.rb

@@ -0,0 +1,190 @@
+require 'roby'
+require 'thor'
+require 'roby/droby/logfile/server'
+require 'roby/droby/logfile/client'
+require 'roby/interface'
+
+module Roby
+    module CLI
+        class Display < Thor
+            Server = Roby::DRoby::Logfile::Server
+
+            default_command 'backward'
+
+            class_option :debug, type: :boolean, default: false
+            class_option :config, type: :string, default: nil,
+                desc: 'path to the roby-display configuration file'
+
+            desc 'backward', 'backward-compatible interface with the old roby-display'
+            option :client, type: :string, lazy_default: "localhost:#{Interface::DEFAULT_PORT}"
+            option :host, type: :string, lazy_default: "localhost:#{Interface::DEFAULT_PORT}"
+            option :vagrant, type: :string, default: nil
+            option :server, type: :numeric
+            option :sampling, type: :numeric
+            def backward(*path)
+                host, port = 'localhost', Server::DEFAULT_PORT
+                if remote_addr = (options[:client] || options[:host])
+                    if options[:host]
+                        Roby.warn_deprecated "--host is deprecated, use 'roby-display client' instead, run roby-display help for more information"
+                    else
+                        Roby.warn_deprecated "roby-display --client=HOST is now roby-display client HOST, run roby-display help for more information"
+                    end
+                    if vagrant_host = options[:vagrant]
+                        _, port = remote_addr.split(':')
+                        remote_addr = "vagrant:#{vagrant_host}:#{port}"
+                    end
+                    client(remote_addr)
+                elsif bind_port = options[:server]
+                    Roby.warn_deprecated "roby-display --server PATH is now roby-display server PATH, run roby-display help for more information"
+                    server(*path, port: bind_port)
+                else
+                    file(*path)
+                end
+            end
+
+            desc 'file PATH', 'inspect an existing log file'
+            option :display, type: :string, desc: 'a display to open right away (relations, chronicle or all)'
+            def file(path)
+                apply_common_options
+
+                with_display do |app, display|
+                    display.open(path)
+                end
+            end
+
+            desc 'client HOST[:PORT]', 'connect to a running Roby instance'
+            option :display, type: :string, desc: 'a display to open right away (relations, chronicle or all)'
+            def client(remote_addr)
+                apply_common_options
+
+                host, port = resolve_remote_host(remote_addr)
+                with_display do |app, display|
+                    display.connect(host, port: port)
+                end
+            end
+
+            desc 'server PATH', "serve the given log file"
+            option :fd, desc: 'the file descriptor of the TCP server socket',
+                type: :numeric
+            option :port, desc: 'port number on which to create the server',
+                type: :numeric, default: Server::DEFAULT_PORT
+            option :sampling, type: :numeric,
+                default: Server::DEFAULT_SAMPLING_PERIOD,
+                desc: 'period in seconds at which the server should poll the log file'
+            def server(path, port: options[:port])
+                # NOTE: the 'port' argument is here so that it can be overriden
+                # in {#backward}
+                apply_common_options
+
+                if server_fd = options[:fd]
+                    server_io = TCPServer.for_fd(server_fd)
+                else
+                    server_io =
+                        begin TCPServer.new(port)
+                        rescue TypeError # Workaround for https://bugs.ruby-lang.org/issues/10203
+                            raise Errno::EADDRINUSE, "Address already in use - bind(2) for \"0.0.0.0\" port #{port}"
+                        end
+                end
+
+                server = Roby::DRoby::Logfile::Server.new(path, options[:sampling], server_io)
+                port = server_io.local_address.ip_port
+                Server.info "Roby log server listening on port #{port}, sampling period=#{options[:sampling]}"
+                Server.info "watching #{path}"
+                server.exec
+            ensure
+                server_io.close if server_io
+            end
+
+            attr_reader :config_path
+
+            no_commands do
+                def apply_common_options
+                    if options[:debug]
+                        Server.logger.level = Logger::DEBUG
+                        Roby::DRoby::Logfile.logger.level = Logger::DEBUG
+                    end
+
+                    if config_path = options[:config]
+                        @config_path = File.expand_path(config_path)
+                    elsif Roby.app.app_dir
+                        @config_path = Roby.app.find_file('config', 'roby-display.yml', order: :specific_first) ||
+                            File.join(Roby.app.app_dir, "config", "roby-display.yml")
+                    end
+                end
+
+                def discover_log_server_port(host, interface_port)
+                    client = Interface.connect_with_tcp_to(host, interface_port)
+                    port = client.log_server_port
+                ensure
+                    client.close if client
+                end
+
+                def resolve_remote_host(host_spec = '')
+                    parts = host_spec.split(':')
+                    if parts[0] == 'vagrant'
+                        vagrant_id = parts[1]
+                        if !vagrant_id
+                            raise ArgumentError, "expected vagrant: to be followed by the ID of a vagrant VM"
+                        end
+                        require 'roby/app/vagrant'
+                        host = Roby::App::Vagrant.resolve_ip(vagrant_id)
+                        port = parts[2]
+                    else
+                        host, port = *parts
+                        host = 'localhost' if !host || host.empty?
+                    end
+                    port = Interface::DEFAULT_PORT.to_s if !port
+
+                    if port[0, 1] != '!'
+                        port = discover_log_server_port(host, Integer(port) || Interface::DEFAULT_PORT)
+                    else
+                        port = Integer(port[1..-1] || Server::DEFAULT_PORT)
+                    end
+                    return host, port
+                end
+
+                def with_display
+                    require 'Qt'
+                    require 'roby/droby/logfile/reader'
+                    require 'roby/droby/plan_rebuilder'
+                    require 'roby/gui/log_display'
+
+                    app = Qt::Application.new(ARGV)
+
+                    display = Roby::GUI::LogDisplay.new
+                    if display_mode = options[:display]
+                        if display_mode == 'all'
+                            display.create_all_displays
+                        else
+                            display.create_display(display_mode)
+                        end
+                    end
+
+                    if config_path
+                        apply_config(display, config_path)
+                    end
+                    yield(app, display)
+                    display.show
+                    app.exec
+                ensure
+                    if config_path
+                        save_config(display, config_path)
+                    end
+                end
+
+                def apply_config(display, config_path)
+                    if File.file?(config_path)
+                        display.load_options(config_path)
+                    end
+                end
+                def save_config(display, config_path)
+                    FileUtils.mkdir_p(File.dirname(config_path))
+                    File.open(config_path, 'w') do |io|
+                        YAML.dump(display.save_options, io)
+                    end
+                end
+            end
+        end
+    end
+end
+