uh-wm 0.0.2.pre → 0.0.2

data/lib/uh/wm/testing/acceptance_helpers.rb

@@ -1,7 +1,11 @@
+require 'uh'
+
 module Uh
   module WM
     module Testing
       module AcceptanceHelpers
+        TIMEOUT_DEFAULT = 2
+
         def uhwm_run options = '-v'
           command = %w[uhwm]
           command << options if options
@@ -9,7 +13,10 @@ module Uh
         end
 
         def uhwm_ensure_stop
-          @process and @process.terminate
+          if @process
+            x_key 'alt+shift+q'
+            @process.terminate
+          end
         end
 
         def uhwm_pid
@@ -20,33 +27,30 @@ module Uh
           @process.stdout
         end
 
-        def uhwm_wait_output message, timeout: 1
-          Timeout.timeout(timeout) do
-            loop do
-              break if case message
-                when Regexp then @process.stdout + @process.stderr =~ message
-                when String then assert_partial_output_interactive message
-              end
-              sleep 0.1
+        def uhwm_wait_output message
+          output = -> { @process.stdout + @process.stderr }
+          timeout_until do
+            case message
+              when Regexp then output.call =~ message
+              when String then output.call.include? message
             end
           end
-        rescue Timeout::Error
-          output = (@process.stdout + @process.stderr).lines
-            .map { |e| "  #{e}" }
-            .join
+        rescue TimeoutError => e
           fail [
-            "expected `#{message}' not seen after #{timeout} seconds in:",
-            "  ```\n#{output}  ```"
+            "expected `#{message}' not seen after #{e.timeout} seconds in:",
+            "  ```\n#{output.call.lines.map { |e| "  #{e}" }.join}  ```"
           ].join "\n"
         end
 
-        def uhwm_run_wait_ready
-          uhwm_run
+        def uhwm_run_wait_ready options = nil
+          if options then uhwm_run options else uhwm_run end
           uhwm_wait_output 'Connected to'
         end
 
         def with_other_wm
-          @other_wm = ChildProcess.build('twm').tap { |o| o.start }
+          @other_wm = ChildProcess.build('twm')
+          @other_wm.start
+          yield
           @other_wm.stop
         end
 
@@ -54,6 +58,19 @@ module Uh
           @other_wm
         end
 
+        def x_client ident: :default
+          @x_clients ||= {}
+          @x_clients[ident] ||= XClient.new(ident)
+        end
+
+        def x_focused_window_id
+          Integer(`xdpyinfo`[/^focus:\s+window\s+(0x\h+)/, 1])
+        end
+
+        def x_input_event_masks
+          `xdpyinfo`[/current input event mask:\s+0x\h+([\w\s]+):/, 1].split(/\s+/).grep /Mask\z/
+        end
+
         def x_key key
           fail "cannot simulate X key `#{key}'" unless system "xdotool key #{key}"
         end
@@ -66,6 +83,111 @@ module Uh
             `sockstat -u`.lines.grep /\s+ruby.+\s+#{pid}/
           end.any?
         end
+
+        def x_window_id **options
+          x_client(options).window_id
+        end
+
+        def x_window_name
+          x_client.window_name
+        end
+
+        def x_window_map times: 1, **options
+          times.times { x_client(options).map }
+          x_client(options).sync
+        end
+
+        def x_window_map_state **options
+          `xwininfo -id #{x_window_id options}`[/Map State: (\w+)/, 1]
+        end
+
+        def x_window_unmap **options
+          x_client(options).unmap
+          x_client(options).sync
+        end
+
+        def x_window_destroy **options
+          x_client(options).destroy
+          x_client(options).sync
+        end
+
+        def x_clients_ensure_stop
+          @x_clients and @x_clients.any? and @x_clients.values.each &:terminate
+        end
+
+
+        private
+
+        def timeout_until
+          timeout = ENV.key?('UHWMTEST_TIMEOUT') ?
+            ENV['UHWMTEST_TIMEOUT'].to_i :
+            TIMEOUT_DEFAULT
+          Timeout.timeout(timeout) do
+            loop do
+              break if yield
+              sleep 0.1
+            end
+          end
+        rescue Timeout::Error
+          fail TimeoutError.new('execution expired', timeout)
+        end
+
+
+        class TimeoutError < ::StandardError
+          attr_reader :timeout
+
+          def initialize message, timeout
+            super message
+            @timeout = timeout
+          end
+        end
+
+        class XClient
+          attr_reader :name
+
+          def initialize name = object_id
+            @name     = "#{self.class.name.split('::').last}/#{name}"
+            @geo      = Geo.new(0, 0, 640, 480)
+            @display  = Display.new.tap { |o| o.open }
+          end
+
+          def terminate
+            @display.close
+          end
+
+          def sync
+            @display.sync false
+          end
+
+          def window
+            @window ||= @display.create_window(@geo).tap do |o|
+              o.name = @name
+            end
+          end
+
+          def window_id
+            @window.id
+          end
+
+          def window_name
+            @name
+          end
+
+          def map
+            window.map
+            self
+          end
+
+          def unmap
+            window.unmap
+            self
+          end
+
+          def destroy
+            window.destroy
+            self
+          end
+        end
       end
     end
   end

data/lib/uh/wm/version.rb

@@ -1,5 +1,5 @@
 module Uh
   module WM
-    VERSION = '0.0.2.pre'
+    VERSION = '0.0.2'
   end
 end

data/lib/uh/wm/workers.rb

@@ -0,0 +1,21 @@
+module Uh
+  module WM
+    module Workers
+      FACTORIES = {
+        block:  ->(options) { Blocking.new(options) },
+        mux:    ->(options) { Mux.new(options) }
+      }.freeze
+
+      class << self
+        def types
+          FACTORIES.keys
+        end
+
+        def build type, **options
+          (FACTORIES[type] or fail ArgumentError, "unknown worker: `#{type}'")
+            .call options
+        end
+      end
+    end
+  end
+end

data/lib/uh/wm/workers/base.rb

@@ -0,0 +1,27 @@
+module Uh
+  module WM
+    module Workers
+      class Base
+        CALLBACKS = %w[before_wait on_timeout on_read on_read_next].freeze
+
+        def initialize **options
+          @ios = []
+        end
+
+        def watch io
+          @ios << io
+        end
+
+        CALLBACKS.each do |m|
+          define_method m do |*_, &block|
+            if block
+              instance_variable_set "@#{m}".to_sym, block
+            else
+              instance_variable_get "@#{m}".to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/uh/wm/workers/blocking.rb

@@ -0,0 +1,11 @@
+module Uh
+  module WM
+    module Workers
+      class Blocking < Base
+        def work_events
+          @on_read_next.call
+        end
+      end
+    end
+  end
+end

data/lib/uh/wm/workers/mux.rb

@@ -0,0 +1,18 @@
+module Uh
+  module WM
+    module Workers
+      class Mux < Base
+        def initialize timeout: 1
+          super
+          @timeout = timeout
+        end
+
+        def work_events
+          @before_wait.call if @before_wait
+          if res = select(@ios, [], [], @timeout) then @on_read.call res
+          else @on_timeout.call if @on_timeout end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'headless'
+
+require 'uh/wm'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.disable_monkey_patching!
+
+  config.before :all do
+    # Ensure current X display is not available from rspec test suite.
+    ENV.delete 'DISPLAY'
+  end
+
+  config.around :example, :xvfb do |example|
+    Headless.ly do
+      example.run
+    end
+  end
+end

data/spec/support/exit_helpers.rb

@@ -0,0 +1,6 @@
+module ExitHelpers
+  def trap_exit
+    yield
+  rescue SystemExit
+  end
+end

data/spec/support/filesystem_helpers.rb

@@ -0,0 +1,11 @@
+require 'tempfile'
+
+module FileSystemHelpers
+  def with_file content
+    Tempfile.create('uhwm_rspec') do |f|
+      f.write content
+      f.rewind
+      yield f
+    end
+  end
+end

data/spec/uh/wm/actions_handler_spec.rb

@@ -0,0 +1,30 @@
+module Uh
+  module WM
+    RSpec.describe ActionsHandler do
+      let(:env)         { Env.new(StringIO.new) }
+      let(:events)      { Dispatcher.new }
+      subject(:actions) { described_class.new env, events }
+
+      describe '#evaluate' do
+        it 'evaluates given code' do
+          expect { actions.evaluate proc { throw :action_code } }
+            .to throw_symbol :action_code
+        end
+      end
+
+      describe '#quit' do
+        it 'emits the quit event' do
+          expect(events).to receive(:emit).with :quit
+          actions.quit
+        end
+      end
+
+      describe '#layout_*' do
+        it 'delegates messages to the layout with handle_ prefix' do
+          expect(env.layout).to receive :handle_screen_sel
+          actions.layout_screen_sel :succ
+        end
+      end
+    end
+  end
+end

data/spec/uh/wm/cli_spec.rb

@@ -0,0 +1,214 @@
+require 'support/exit_helpers'
+
+module Uh
+  module WM
+    RSpec.describe CLI do
+      include ExitHelpers
+
+      let(:stdout)    { StringIO.new }
+      let(:stderr)    { StringIO.new }
+      let(:arguments) { [] }
+      subject(:cli)   { described_class.new arguments, stdout: stdout }
+
+      describe '.run' do
+        subject(:run) do
+          described_class.run arguments, stdout: stdout, stderr: stderr
+        end
+
+        # Prevent Runner from connecting a Manager and blocking.
+        before { allow(Runner).to receive :run }
+
+        it 'builds a new CLI with given arguments' do
+          expect(described_class)
+            .to receive(:new).with(arguments, stdout: stdout).and_call_original
+          run
+        end
+
+        it 'parses new CLI arguments' do
+          cli
+          allow(described_class).to receive(:new) { cli }
+          expect(cli).to receive :parse_arguments!
+          run
+        end
+
+        it 'runs new CLI' do
+          cli
+          allow(described_class).to receive(:new) { cli }
+          expect(cli).to receive :run
+          run
+        end
+
+        context 'with invalid arguments' do
+          let(:arguments) { %w[--unknown-option] }
+
+          it 'prints the usage on standard error stream' do
+            trap_exit { run }
+            expect(stderr.string).to match /\AUsage: .+/
+          end
+
+          it 'exits with a return status of 64' do
+            expect { run }.to raise_error(SystemExit) do |e|
+              expect(e.status).to eq 64
+            end
+          end
+        end
+
+        context 'when the new CLI raises a runtime error' do
+          before do
+            allow(cli).to receive(:run) { fail RuntimeError, 'some error' }
+            allow(described_class).to receive(:new) { cli }
+          end
+
+          it 'exits with a return status of 70' do
+            expect { run }.to raise_error(SystemExit) do |e|
+              expect(e.status).to eq 70
+            end
+          end
+
+          it 'formats the error' do
+            trap_exit { run }
+            expect(stderr.string)
+              .to match /\AUh::WM::RuntimeError: some error\n/
+          end
+
+          it 'does not output a backtrace' do
+            trap_exit { run }
+            expect(stderr.string).not_to include __FILE__
+          end
+
+          context 'when debug mode is enabled' do
+            let(:arguments) { %w[-d] }
+
+            it 'outputs a backtrace' do
+              trap_exit { run }
+              expect(stderr.string).to include __FILE__
+            end
+          end
+        end
+      end
+
+      describe '#initialize' do
+        it 'builds an env with given stdout' do
+          expect(cli.env.output).to be stdout
+        end
+
+        it 'syncs the output' do
+          expect(stdout).to receive(:sync=).with(true)
+          cli
+        end
+      end
+
+      describe '#run' do
+        it 'runs a runner with the env' do
+          expect(Runner).to receive(:run).with(cli.env)
+          cli.run
+        end
+      end
+
+      describe '#parse_arguments!' do
+        context 'with verbose option' do
+          let(:arguments) { %w[-v] }
+
+          it 'sets the env as verbose' do
+            cli.parse_arguments!
+            expect(cli.env).to be_verbose
+          end
+
+          it 'tells the env to log its logger level' do
+            expect(cli.env).to receive :log_logger_level
+            cli.parse_arguments!
+          end
+        end
+
+        context 'with debug option' do
+          let(:arguments) { %w[-d] }
+
+          it 'sets the env as debug' do
+            cli.parse_arguments!
+            expect(cli.env).to be_debug
+          end
+
+          it 'tells the env to log its logger level' do
+            expect(cli.env).to receive :log_logger_level
+            cli.parse_arguments!
+          end
+        end
+
+        context 'with run control option' do
+          let(:arguments) { %w[-f uhwmrc.rb] }
+
+          it 'assigns run control file path in the env' do
+            cli.parse_arguments!
+            expect(cli.env.rc_path).to eq 'uhwmrc.rb'
+          end
+        end
+
+        context 'with require option' do
+          let(:arguments) { %w[-r abbrev] }
+
+          it 'requires the given ruby feature' do
+            expect { cli.parse_arguments! }
+              .to change { $LOADED_FEATURES.grep(/abbrev/).any? }
+              .from(false).to(true)
+          end
+        end
+
+        context 'with layout option' do
+          let(:arguments) { %w[-l Object] }
+
+          it 'assigns the layout class in the env' do
+            cli.parse_arguments!
+            expect(cli.env.layout_class).to eq Object
+          end
+        end
+
+        context 'with worker option' do
+          let(:arguments) { %w[-w mux] }
+
+          it 'assigns the worker type in the env' do
+            cli.parse_arguments!
+            expect(cli.env.worker).to eq :mux
+          end
+        end
+
+        context 'with help option' do
+          let(:arguments) { %w[-h] }
+
+          it 'prints the usage banner on standard output' do
+            trap_exit { cli.parse_arguments! }
+            expect(stdout.string).to match /\AUsage: .+/
+          end
+
+          it 'prints options usage on standard output' do
+            trap_exit { cli.parse_arguments! }
+            expect(stdout.string).to match /\n^options:\n\s+-/
+          end
+        end
+
+        context 'with version option' do
+          let(:arguments) { %w[-V] }
+
+          it 'prints the version on standard output' do
+            trap_exit { cli.parse_arguments! }
+            expect(stdout.string).to eq "#{::Uh::WM::VERSION}\n"
+          end
+
+          it 'exits with a return status of 0' do
+            expect { cli.parse_arguments! }.to raise_error(SystemExit) do |e|
+              expect(e.status).to eq 0
+            end
+          end
+        end
+
+        context 'with invalid option' do
+          let(:arguments) { %w[--unknown-option] }
+
+          it 'raises a CLI::ArgumentError' do
+            expect { cli.parse_arguments! }
+              .to raise_error CLI::ArgumentError
+          end
+        end
+      end
+    end
+  end
+end