fusuma 2.0.0.pre2 → 2.0.4

data/spec/lib/plugin/events/records/gesture_record_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/plugin/events/records/gesture_record'
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        RSpec.describe GestureRecord do
+          let(:record) do
+            described_class.new(status: 'updating',
+                                gesture: 'swipe',
+                                finger: 3,
+                                direction: direction)
+          end
+          let(:direction) { GestureRecord::Delta.new(0, 0, 1, 0) }
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/events/records/record_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/plugin/events/records/record'
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        RSpec.describe Record do
+          class DummyRecord < Records::Record
+            def type
+              :dummy
+            end
+          end
+          let(:record) { described_class.new }
+
+          describe '#type' do
+            it { expect { record.type }.to raise_error(NotImplementedError) }
+
+            context 'override #type' do
+              let(:record) { DummyRecord.new }
+              it { expect { record.type }.not_to raise_error(NotImplementedError) }
+              it { expect(record.type).to eq :dummy }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/events/records/text_record_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/plugin/events/records/text_record'
+
+module Fusuma
+  module Plugin
+    module Events
+      module Records
+        RSpec.describe TextRecord do
+          let(:record) { described_class.new('this is dummy') }
+
+          describe '#type' do
+            subject { record.type }
+            it { is_expected.to eq :text }
+          end
+
+          describe '#to_s' do
+            subject { record.to_s }
+            it { is_expected.to eq 'this is dummy' }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/executors/command_executor_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/plugin/executors/command_executor'
+require './lib/fusuma/plugin/events/event'
+
+module Fusuma
+  module Plugin
+    module Executors
+      RSpec.describe CommandExecutor do
+        before do
+          index = Config::Index.new([:dummy, 1, :direction])
+          record = Events::Records::IndexRecord.new(index: index)
+          @event = Events::Event.new(tag: 'dummy_detector', record: record)
+          @executor = CommandExecutor.new
+        end
+
+        around do |example|
+          ConfigHelper.load_config_yml = <<~CONFIG
+            dummy:
+              1:
+                direction:
+                  command: 'echo dummy'
+                  interval: 1
+          CONFIG
+
+          example.run
+
+          Config.custom_path = nil
+        end
+
+        describe '#execute' do
+          it 'spawn' do
+            command = 'echo dummy'
+            env = {}
+            expect(Process).to receive(:spawn).with(env, command)
+            expect(Process).to receive(:detach).with(anything)
+            @executor.execute(@event)
+          end
+        end
+
+        describe '#executable?' do
+          context 'detector is matched with config file' do
+            it { expect(@executor.executable?(@event)).to be_truthy }
+          end
+
+          context 'detector is NOT matched with config file' do
+            before do
+              @event.tag = 'invalid'
+            end
+            it { expect(@executor.executable?(@event)).to be_falsey }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/executors/executor_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require './lib/fusuma/config'
+require './lib/fusuma/plugin/executors/executor'
+require './lib/fusuma/plugin/detectors/detector'
+require './lib/fusuma/plugin/events/event'
+
+module Fusuma
+  module Plugin
+    module Executors
+      RSpec.describe Executor do
+        before { @executor = Executor.new }
+
+        describe '#execute' do
+          it do
+            expect { @executor.execute('dummy') }.to raise_error(NotImplementedError)
+          end
+        end
+
+        describe '#executable?' do
+          it do
+            expect { @executor.executable?('dummy') }.to raise_error(NotImplementedError)
+          end
+        end
+      end
+
+      class DummyExecutor < Executor
+        def execute(event)
+          index = Config::Index.new([*event.record.index.keys, :dummy])
+          content = Config.search(index)
+
+          # stdout
+          puts content if executable?(event)
+        end
+
+        def executable?(event)
+          event.tag == 'dummy'
+        end
+      end
+
+      RSpec.describe DummyExecutor do
+        before do
+          index = Config::Index.new([:dummy_gesture,
+                                     Config::Index::Key.new(:dummy_direction, skippable: true)])
+          record = Events::Records::IndexRecord.new(index: index)
+          @event = Events::Event.new(tag: 'dummy', record: record)
+          @executor = DummyExecutor.new
+        end
+
+        around do |example|
+          ConfigHelper.load_config_yml = <<~CONFIG
+            dummy_gesture:
+              dummy_direction:
+                dummy: 'echo dummy'
+                interval: 0.3
+
+            plugin:
+             executors:
+               dummy_executor:
+                 dummy: dummy
+          CONFIG
+
+          example.run
+
+          Config.custom_path = nil
+        end
+
+        describe '#execute' do
+          it { expect { @executor.execute(@event) }.to output("echo dummy\n").to_stdout }
+          context 'without executable' do
+            before do
+              allow(@executor).to receive(:executable?).and_return false
+            end
+            it { expect { @executor.execute(@event) }.not_to output("echo dummy\n").to_stdout }
+          end
+        end
+
+        describe '#executable?' do
+          it { expect(@executor.executable?(@event)).to be_truthy }
+        end
+
+        describe 'interval' do
+          it 'should return interval from Config' do
+            interval_time = 0.3 * DummyExecutor::BASE_ONESHOT_INTERVAL
+            expect(@executor.interval(@event)).to eq interval_time
+          end
+
+          context 'without skippable direction' do
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                dummy_gesture:
+                  interval: 0.1
+                  dummy_direction:
+                    dummy: 'echo dummy'
+
+                plugin:
+                 executors:
+                   dummy_executor:
+                     dummy: dummy
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+            it 'should not return parent interval' do
+              expect(@executor.interval(@event)).to eq DummyExecutor::BASE_ONESHOT_INTERVAL
+              expect(@executor.interval(@event)).not_to eq 0.1 * DummyExecutor::BASE_ONESHOT_INTERVAL
+            end
+
+            context 'with Config::Searcher.skip' do
+              it 'should return parent interval' do
+                Config::Searcher.skip do
+                  expect(@executor.interval(@event)).to eq 0.1 * DummyExecutor::BASE_ONESHOT_INTERVAL
+                end
+              end
+            end
+          end
+        end
+
+        describe 'enough_interval?' do
+          it 'should return true at first time' do
+            expect(@executor.enough_interval?(@event)).to eq true
+          end
+
+          context 'after update_interval' do
+            before do
+              @executor.update_interval(@event)
+            end
+            it 'should return false' do
+              expect(@executor.enough_interval?(@event)).to eq false
+            end
+
+            context 'after wait interval time' do
+              before do
+                # dummy_gesture/dummy_direction/interval => 0.3
+                interval_time = 0.3 * DummyExecutor::BASE_ONESHOT_INTERVAL
+
+                @event2 = Events::Event.new(
+                  time: @event.time + interval_time,
+                  tag: 'dummy',
+                  record: @event.record
+                )
+              end
+              it 'should return true after wait' do
+                expect(@executor.enough_interval?(@event2)).to eq true
+              end
+            end
+          end
+        end
+
+        describe '#config_params' do
+          it { expect(@executor.config_params).to eq(dummy: 'dummy') }
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/filters/filter_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+require './lib/fusuma/config'
+require './lib/fusuma/plugin/filters/filter'
+require './lib/fusuma/plugin/events/event'
+
+module Fusuma
+  module Plugin
+    module Filters
+      class DummyFilter < Filter
+        DEFAULT_SOURCE = 'dummy_input'
+
+        def config_param_types
+          {
+            source: String
+          }
+        end
+      end
+
+      RSpec.describe DummyFilter do
+        let(:filter) { DummyFilter.new }
+
+        describe '#source' do
+          subject { filter.source }
+
+          it { is_expected.to eq DummyFilter::DEFAULT_SOURCE }
+
+          context 'with config' do
+            around do |example|
+              @custom_source = 'custom_input'
+
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                 filters:
+                   dummy_filter:
+                     source: #{@custom_source}
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it { is_expected.to eq @custom_source }
+          end
+        end
+
+        describe '#filter' do
+          subject { filter.filter(event) }
+          let(:event) { Events::Event.new(tag: 'dummy_input', record: 'dummy') }
+
+          context 'when filter#keep? return false' do
+            before do
+              allow(filter).to receive(:keep?).and_return(false)
+            end
+
+            it { is_expected.to be nil }
+          end
+
+          context 'when filter#keep? return true' do
+            before do
+              allow(filter).to receive(:keep?).and_return(true)
+            end
+
+            it { is_expected.to be event }
+          end
+        end
+
+        describe '#config_params' do
+          around do |example|
+            ConfigHelper.load_config_yml = <<~CONFIG
+              plugin:
+               filters:
+                 dummy_filter:
+                   dummy: dummy
+            CONFIG
+
+            example.run
+
+            Config.custom_path = nil
+          end
+
+          subject { filter.config_params }
+          it { is_expected.to eq(dummy: 'dummy') }
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/filters/libinput_filter_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+
+require './lib/fusuma/config'
+require './lib/fusuma/plugin/filters/libinput_device_filter'
+require './lib/fusuma/plugin/events/event'
+
+module Fusuma
+  module Plugin
+    module Filters
+      RSpec.describe LibinputDeviceFilter do
+        before do
+          @filter = LibinputDeviceFilter.new
+        end
+
+        describe '#source' do
+          it { expect(@filter.source).to eq LibinputDeviceFilter::DEFAULT_SOURCE }
+
+          context 'with config' do
+            around do |example|
+              @custom_source = 'custom_input'
+
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                 filters:
+                   libinput_device_filter:
+                     source: #{@custom_source}
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it { expect(@filter.source).to eq @custom_source }
+          end
+        end
+
+        describe '#filter' do
+          before do
+            @event = Events::Event.new(tag: 'libinput_command_input', record: 'dummy')
+          end
+
+          context 'when filter#keep? return false' do
+            before do
+              allow(@filter).to receive(:keep?).and_return(false)
+            end
+
+            it { expect(@filter.filter(@event)).to be nil }
+          end
+
+          context 'when filter#keep? return true' do
+            before do
+              allow(@filter).to receive(:keep?).and_return(true)
+            end
+
+            it { expect(@filter.filter(@event)).to be @event }
+          end
+        end
+
+        describe '#keep?' do
+          before do
+            device = Device.new(id: 'event18', name: 'Awesome Touchpad', available: true)
+            allow(Device).to receive(:all).and_return([device])
+            @keep_device = LibinputDeviceFilter::KeepDevice.new(name_patterns: [])
+            allow(@filter).to receive(:keep_device).and_return(@keep_device)
+          end
+
+          context 'when including record generated from touchpad' do
+            before do
+              text = ' event18  GESTURE_SWIPE_UPDATE  +1.44s  4 11.23/ 1.00 (36.91/ 3.28 unaccelerated) '
+              @event = Events::Event.new(tag: 'libinput_command_input', record: text)
+            end
+            it 'should keep record' do
+              expect(@filter.keep?(@event.record)).to be true
+            end
+
+            context 'when including -' do
+              before do
+                text = '-event18  GESTURE_SWIPE_UPDATE  +1.44s  4 11.23/ 1.00 (36.91/ 3.28 unaccelerated) '
+                @event = Events::Event.new(tag: 'libinput_command_input', record: text)
+              end
+              it 'should keep record' do
+                expect(@filter.keep?(@event.record)).to be true
+              end
+            end
+          end
+          context 'when new device is added' do
+            before do
+              text = '-event18 DEVICE_ADDED Apple Wireless Trackpad seat0 default group13 cap:pg size 132x112mm tap(dl off) left scroll-nat scroll-2fg-edge click-buttonareas-clickfing '
+              @event = Events::Event.new(tag: 'libinput_command_input', record: text)
+            end
+            it 'should reset KeepDevice' do
+              expect(@keep_device).to receive(:reset)
+              @filter.keep?(@event.record)
+            end
+
+            it 'discard DEVICE_ADDED record' do
+              expect(@filter.keep?(@event.record)).to be false
+            end
+
+            context 'when keep device is NOT matched' do
+              before do
+                @keep_device = LibinputDeviceFilter::KeepDevice.new(name_patterns: ['Microsoft Arc Mouse'])
+                allow(@filter).to receive(:keep_device).and_return(@keep_device)
+              end
+              it 'should NOT reset KeepDevice' do
+                expect(@keep_device).not_to receive(:reset)
+                # NOTE: @event.record is 'Apple Wireless Touchpad'
+                @filter.keep?(@event.record)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end