LittleWeasel 3.0.3 → 5.0.0

data/spec/lib/LittleWeasel/filters/word_filter_managable_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Filters::WordFilterManagable, type: :module do
+  include_context 'mock word filters'
+
+  WordFilterManagable = described_class
+
+  subject do
+    Class.new do
+      include WordFilterManagable
+      include LittleWeasel::Modules::Configurable
+
+      def initialize(word_filters)
+        self.word_filters = word_filters
+      end
+    end.new(word_filters)
+  end
+
+  let(:word_filters) { [numeric_filter] }
+  let(:numeric_filter) { LittleWeasel::Filters::EnUs::NumericFilter.new }
+
+  #clear_filters
+  describe '#clear_filters' do
+    it 'sets #word_filters to an empty Array ([])' do
+      expect { subject.clear_filters }.to \
+        change { subject.word_filters.count }.from(1).to(0)
+    end
+  end
+
+  #add_filters
+  describe '#add_filters' do
+    context 'when argument word_filters is nil' do
+      context 'when no block is passed' do
+        it 'raises an error' do
+          expect { subject.add_filters }.to raise_error 'A block is required if argument word_filters is nil'
+        end
+      end
+
+      context 'when a block is passed' do
+        before do
+          subject.add_filters do |word_filters|
+            word_filters << WordFilter01.new
+            word_filters << WordFilter02.new
+          end
+        end
+
+        it 'the word filters are appended to the word_filters Array' do
+          expect(subject.word_filters.count).to eq 3
+          expect(subject.word_filters).to include(a_kind_of(WordFilter01))
+          expect(subject.word_filters).to include(a_kind_of(WordFilter02))
+          expect(subject.word_filters).to include(a_kind_of(LittleWeasel::Filters::EnUs::NumericFilter))
+        end
+      end
+    end
+
+    context 'when argument word_filters is a blank Array ([])' do
+      it 'nothing is changed' do
+        expect { subject.add_filters(word_filters: []) }.to_not change { subject.word_filters.count }.from(subject.word_filters.count)
+      end
+    end
+
+    context 'when argument word_filters is not an Array' do
+      it 'raises an error' do
+        expect { subject.add_filters(word_filters: :not_an_array) }.to raise_error(/Argument word_filters is not an Array:/)
+      end
+    end
+
+    context 'when argument word_filters is NOT nil' do
+      it 'the word filters passed to the method are appended to the #word_filters Array' do
+        expect(subject.add_filters(word_filters: [WordFilter01.new, WordFilter02.new]).count).to eq 3
+        expect(subject.word_filters).to include(a_kind_of(WordFilter01))
+        expect(subject.word_filters).to include(a_kind_of(WordFilter02))
+        expect(subject.word_filters).to include(a_kind_of(LittleWeasel::Filters::EnUs::NumericFilter))
+      end
+    end
+
+    context 'when a block is passed' do
+      before do
+        subject.add_filters do |word_filters|
+          word_filters << WordFilter01.new
+          word_filters << WordFilter02.new
+        end
+      end
+
+      it 'word filters added from the block are appended to the #word_filters Array' do
+        expect(subject.word_filters.count).to eq 3
+        expect(subject.word_filters).to include(a_kind_of(WordFilter01))
+        expect(subject.word_filters).to include(a_kind_of(WordFilter02))
+        expect(subject.word_filters).to include(a_kind_of(LittleWeasel::Filters::EnUs::NumericFilter))
+      end
+    end
+  end
+
+  #replace_filters
+  describe '#replace_filters' do
+    it 'replaces any existing word filters' do
+      expect(subject.word_filters.count).to eq 1
+      expect(subject.word_filters).to include(a_kind_of(LittleWeasel::Filters::EnUs::NumericFilter))
+      expect(subject.replace_filters(word_filters: [WordFilter01.new, WordFilter02.new]).count).to eq 2
+      expect(subject.word_filters).to include(a_kind_of(WordFilter01))
+      expect(subject.word_filters).to include(a_kind_of(WordFilter02))
+    end
+  end
+
+  #filters_on=
+  describe '#filters_on=' do
+    context 'when a boolean is not passed' do
+      it 'raises an error' do
+        expect { subject.filters_on = :not_a_boolean }.to raise_error(/Argument on is not true or false:/)
+      end
+    end
+
+    context 'when true is assigned' do
+      it 'turns all the filters on' do
+        expect(subject.word_filters.count).to_not be_zero
+        expect(subject.word_filters.all? { |word_filter| word_filter.filter_on? })
+        subject.filters_on = true
+        expect(subject.word_filters.all? { |word_filter| word_filter.filter_off? })
+      end
+    end
+
+    context 'when false is assigned' do
+      before do
+        subject.filters_on = false
+      end
+
+      it 'turns all the filters off' do
+        expect(subject.word_filters.count).to_not be_zero
+        expect(subject.word_filters.all? { |word_filter| word_filter.filter_off? })
+        subject.filters_on = false
+        expect(subject.word_filters.all? { |word_filter| word_filter.filter_on? })
+      end
+    end
+  end
+
+  #filter_match?
+  describe '#filter_match?' do
+    context 'when argument word is not a String' do
+      let(:word) { :not_a_string }
+
+      it 'raises an error' do
+        expect { subject.filter_match? word }.to raise_error "Argument word is not a String: #{word.class}"
+      end
+    end
+
+    context 'when argument word is empty' do
+      let(:word) { '' }
+
+      it 'returns false' do
+        expect(subject.filter_match? word).to eq false
+      end
+    end
+
+    context 'when argument word matches a filter' do
+      before do
+        subject.filters_on = true
+      end
+
+      let(:word) { '123456789' }
+
+      it 'returns true' do
+        expect(subject.filter_match? word).to eq true
+      end
+    end
+
+    context 'when argument word DOES NOT match a filter' do
+      before do
+        subject.filters_on = false
+      end
+
+      let(:word) { '123456789' }
+
+      it 'returns false' do
+        expect(subject.filter_match? word).to eq false
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/filters/word_filter_spec.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Filters::WordFilter do
+  subject { described_class.new }
+
+  #.new
+  describe '.new' do
+    it 'instantiates the object' do
+      expect { subject }.to_not raise_error
+    end
+
+    it 'sets #filter_on to true by default' do
+      expect(subject.filter_on).to eq true
+    end
+  end
+
+  #filter_off!
+  describe '#filter_off!' do
+    before do
+      subject.filter_off!
+    end
+
+    it 'sets the filter off' do
+      expect(subject.filter_off?).to eq true
+    end
+  end
+
+  #filter_on
+  describe '#filter_on' do
+    context 'when set to true' do
+      before do
+        subject.filter_on = true
+      end
+
+      it 'returns true' do
+        expect(subject.filter_on).to eq true
+      end
+    end
+
+    context 'when set to false' do
+      before do
+        subject.filter_on = false
+      end
+
+      it 'returns false' do
+        expect(subject.filter_on).to eq false
+      end
+    end
+  end
+
+  #filter_on=
+  describe '#filter_on=' do
+    context 'when argument value is valid' do
+      context 'when true' do
+        before do
+          subject.filter_on = false
+          expect(subject.filter_off?).to eq true
+        end
+
+        it 'sets #filter_on to true' do
+          subject.filter_on = true
+          expect(subject.filter_on).to eq true
+        end
+      end
+
+      context 'when false' do
+        before do
+          subject.filter_on = true
+          expect(subject.filter_on?).to eq true
+        end
+
+        it 'sets #filter_on to false' do
+          subject.filter_on = false
+          expect(subject.filter_on).to eq false
+        end
+      end
+    end
+
+    context 'when argument value is INVALID' do
+      context 'when argument value is not true or false' do
+        let(:filter_on) { :not_true_or_false }
+
+        it 'raises an error' do
+          expect { subject.filter_on = filter_on }.to raise_error(/Argument value is not true or false/)
+        end
+      end
+    end
+  end
+
+  #filter_on?
+  describe '#filter_on?' do
+    context 'when #filter_on is true' do
+      it 'returns true' do
+        subject.filter_on = true
+        expect(subject.filter_on?).to eq true
+      end
+    end
+
+    context 'when #filter_on is false' do
+      it 'returns false' do
+        subject.filter_on = false
+        expect(subject.filter_on?).to eq false
+      end
+    end
+  end
+
+  #filter_match?
+  describe '#filter_match?' do
+    let(:word) { 'word' }
+
+    context 'when not overridden' do
+      it 'raises an error' do
+        expect { subject.filter_match? 'boom' }.to raise_error LittleWeasel::Errors::MustOverrideError
+      end
+    end
+
+    context 'when #filter_match? returns true' do
+      before { allow(subject.class).to receive(:filter_match?).and_return(true) }
+
+      context 'when #filter_on? is true' do
+        it_behaves_like 'the filter matches and #filter_on? is true'
+      end
+
+      context 'when #filter_on? is false' do
+        before do
+          subject.filter_on = false
+        end
+
+        it_behaves_like 'the filter matches and #filter_on? is false'
+      end
+    end
+
+    context 'when #filter_match? returns false' do
+      before { allow(subject.class).to receive(:filter_match?).and_return(false) }
+
+      context 'when #filter_on? is true' do
+        it_behaves_like 'the filter DOES NOT match and #filter_on? is true'
+      end
+
+      context 'when #filter_on? is false' do
+        before do
+          subject.filter_on = false
+        end
+
+        it_behaves_like 'the filter DOES NOT match and #filter_on? is false'
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/filters/word_filter_validatable_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Filters::WordFilterValidatable, type: :module do
+  WordFilterValidatable = described_class
+
+  class Subject
+    include WordFilterValidatable
+  end
+
+  subject { Subject.new }
+
+  let(:filter_class) do
+    filter = Class.new do
+      def filter_on?; end
+      def filter_off?; end
+      def filter_on; end
+      def filter_on=; end
+      def filter_match?; end
+      def self.filter_match?; end
+    end
+    filter
+  end
+
+  let(:numeric_filter) do
+    filter_class.new
+  end
+  let(:expected_error_message) { "Argument word_filter does not quack right: #{numeric_filter.class}" }
+
+  #validate_word_filter
+  describe '#validate_word_filter' do
+    context 'when argument word_filter quacks correctly' do
+      it 'does not raise an error' do
+        expect { subject.validate_word_filter(word_filter: numeric_filter) }.to_not raise_error
+      end
+    end
+
+    context 'when argument word_filter DOES NOT quack correctly to the right instance methods' do
+      context 'when word_filter does not respond to #filter_on?' do
+        before { numeric_filter.instance_eval("undef #{method_to_check}") }
+        let(:method_to_check) { :filter_on? }
+
+        it 'raises an error' do
+          expect { subject.validate_word_filter(word_filter: numeric_filter) }.to raise_error \
+            expected_error_message
+        end
+      end
+
+      context 'when word_filter does not respond to #filter_on' do
+        before { numeric_filter.instance_eval("undef #{method_to_check}") }
+        let(:method_to_check) { :filter_on }
+
+        it 'raises an error' do
+          expect { subject.validate_word_filter(word_filter: numeric_filter) }.to raise_error \
+            expected_error_message
+        end
+      end
+
+      context 'when word_filter does not respond to #filter_on=' do
+        before { numeric_filter.instance_eval("undef #{method_to_check}") }
+        let(:method_to_check) { :filter_on= }
+
+        it 'raises an error' do
+          expect { subject.validate_word_filter(word_filter: numeric_filter) }.to raise_error \
+            expected_error_message
+        end
+      end
+
+      context 'when word_filter does not respond to #filter_match?' do
+        before { numeric_filter.instance_eval("undef #{method_to_check}") }
+        let(:method_to_check) { :filter_match? }
+
+        it 'raises an error' do
+          expect { subject.validate_word_filter(word_filter: numeric_filter) }.to raise_error \
+            expected_error_message
+        end
+      end
+    end
+
+    context 'when argument word_filter DOES NOT quack correctly to the right class methods' do
+      before { allow(filter_class).to receive(:respond_to?).with(method_to_check).and_return(false) }
+
+      context 'when word_filter class does not respond to #filter_match?' do
+        let(:method_to_check) { :filter_match? }
+
+        it 'raises an error' do
+          expect { subject.validate_word_filter(word_filter: numeric_filter) }.to raise_error \
+            expected_error_message
+        end
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/filters/word_filters_validatable_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Filters::WordFiltersValidatable, type: :module do
+  include_context 'mock word filters'
+
+  WordFiltersValidatable = described_class
+
+  class Subject
+    include WordFiltersValidatable
+  end
+
+  subject { Subject.new }
+
+  let(:word_filters) do
+    [
+      WordFilter01.new,
+      WordFilter02.new
+    ]
+  end
+  let(:expected_error_message) { "Argument word_filter does not quack right: #{numeric_filter.class}" }
+
+  #validate_word_filters
+  describe '#validate_word_filters' do
+    context 'when argument word_filters is not an Array' do
+      let(:word_filters) { :not_an_array}
+
+      it 'raises an error' do
+        expect { subject.validate_word_filters(word_filters: word_filters) }.to raise_error "Argument word_filters is not an Array: #{word_filters.class}"
+      end
+    end
+
+    context 'when argument word_filters contains valid word filters' do
+      it 'does not raise an error' do
+        expect { subject.validate_word_filters(word_filters: word_filters) }.to_not raise_error
+      end
+    end
+
+    context 'when argument word_filters contains INVALID word filters' do
+      let(:word_filters) { [Object.new] }
+
+      it 'does not raise an error' do
+        expect { subject.validate_word_filters(word_filters: word_filters) }.to raise_error  "Argument word_filter does not quack right: #{word_filters[0].class}"
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/integraton_tests/dictionary_integration_spec.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Dictionary integration', type: :integration do
+  include_context 'dictionary keys'
+  include_context 'mock word preprocessors'
+
+  subject { create(:dictionary_manager) }
+
+  before(:each) { LittleWeasel.configure { |config| config.reset } }
+
+  let(:dictionary) do
+    subject.create_dictionary_from_file(dictionary_key: dictionary_key, file: dictionary_file_path,
+      word_filters: word_filters, word_preprocessors: word_preprocessors)
+  end
+  let(:dictionary_key) { dictionary_key_for(language: :en, region: :us) }
+  let(:dictionary_cache) { subject.dictionary_cache }
+  let(:dictionary_metadata) { subject.dictionary_metadata }
+  let(:dictionary_file_path) { dictionary_path_for(file_name: dictionary_key.key) }
+  let(:dictionary_words) { dictionary_words_for(dictionary_file_path: dictionary_file_path) }
+  let(:word_filters) {}
+  let(:word_preprocessors) {}
+
+  #word_results
+  describe '#word_results' do
+    describe 'when using word filters' do
+      let(:word_filters) { [LittleWeasel::Filters::EnUs::NumericFilter.new] }
+      let(:number) { 1_000.to_s }
+
+      context 'with word filters turned on' do
+        let(:word_results) { dictionary.word_results(number) }
+
+        it '#success? returns true' do
+          expect(word_results.success?).to eq true
+        end
+
+        it '#filter_match? returns true' do
+          expect(word_results.filter_match?).to eq true
+        end
+
+        it '#filters_matched returns the filter(s) that were matched' do
+          expect(word_results.filters_matched).to eq [:numeric_filter]
+        end
+
+        it '#word_valid? returns false' do
+          expect(word_results.word_valid?).to eq false
+        end
+
+        it '#original_word returns the original word' do
+          expect(word_results.preprocessed_word_or_original_word).to eq number
+        end
+
+        it '#preprocessed_word return nil because no word preprocessors were applied' do
+          expect(word_results.preprocessed_word).to be_nil
+        end
+
+        it '#preprocessed_word_or_original_word returns the original word' do
+          expect(word_results.preprocessed_word_or_original_word).to eq number
+        end
+
+        it '#word_cached? returns false if the word is not in the dictionary' do
+          expect(word_results.word_cached?).to eq false
+        end
+
+        it '#word_cached? returns true 2nd-nth time the word was searched if invalid words are being cached by any metadata processing' do
+          dictionary.word_results(number)
+          expect(word_results.word_cached?).to eq true
+        end
+      end
+
+      context 'with filters turned off' do
+        before do
+          dictionary.filters_on = false
+        end
+
+        let(:word_results) { dictionary.word_results(number) }
+
+        it '#success? returns false' do
+          expect(word_results.success?).to eq false
+        end
+
+        it '#filter_match? returns false' do
+          expect(word_results.filter_match?).to eq false
+        end
+
+        it '#filters_matched returns an empty Array' do
+          expect(word_results.filters_matched).to eq []
+        end
+
+        it '#word_valid? returns false' do
+          expect(word_results.word_valid?).to eq false
+        end
+
+        it '#original_word returns the original word' do
+          expect(word_results.original_word).to eq number
+        end
+
+        it '#preprocessed_word return nil because no word preprocessors were applied' do
+          expect(word_results.preprocessed_word).to be_nil
+        end
+
+        it '#preprocessed_word_or_original_word returns the original word' do
+          expect(word_results.preprocessed_word_or_original_word).to eq number
+        end
+
+        it '#word_cached? returns false if the word is not in the dictionary' do
+          expect(word_results.word_cached?).to eq false
+        end
+
+        it '#word_cached? returns true 2nd-nth time the word was searched if invalid words are being cached by any metadata processing' do
+          dictionary.word_results(number)
+          expect(word_results.word_cached?).to eq true
+        end
+      end
+    end
+
+    describe 'when using word preprocessors' do
+      let(:word_preprocessors) { [DowncaseWordPreprocessor.new(order: 0)] }
+      let(:word) { 'ApPlE' }
+      let(:word_results) { dictionary.word_results(word) }
+
+      context 'with preprocessors turned on' do
+        it '#success? returns true' do
+          expect(word_results.success?).to eq true
+        end
+
+        it '#filter_match? returns false' do
+          expect(word_results.filter_match?).to eq false
+        end
+
+        it '#filters_matched returns the filter(s) that were matched' do
+          expect(word_results.filters_matched).to eq []
+        end
+
+        it '#word_valid? returns true' do
+          expect(word_results.word_valid?).to eq true
+        end
+
+        it '#original_word returns the original word' do
+          expect(word_results.original_word).to eq word
+        end
+
+        it '#preprocessed_word returns the preprocessed word' do
+          expect(word_results.preprocessed_word).to eq word.downcase
+        end
+
+        it '#preprocessed_word_or_original_word returns the preprocessed word' do
+          expect(word_results.preprocessed_word_or_original_word).to eq word.downcase
+        end
+
+        it '#word_cached? returns true if the word is in the dictionary' do
+          expect(word_results.word_cached?).to eq true
+        end
+      end
+
+      context 'with preprocessors turned off' do
+        before do
+          dictionary.preprocessors_on = false
+        end
+
+        it '#success? returns false' do
+          expect(word_results.success?).to eq false
+        end
+
+        it '#filter_match? returns false' do
+          expect(word_results.filter_match?).to eq false
+        end
+
+        it '#filters_matched returns the filter(s) that were matched' do
+          expect(word_results.filters_matched).to eq []
+        end
+
+        it '#word_valid? returns false' do
+          expect(word_results.word_valid?).to eq false
+        end
+
+        it '#original_word returns the original word' do
+          expect(word_results.original_word).to eq word
+        end
+
+        it '#preprocessed_word returns nil' do
+          expect(word_results.preprocessed_word).to be_nil
+        end
+
+        it '#preprocessed_word_or_original_word returns the original word' do
+          expect(word_results.preprocessed_word_or_original_word).to eq word
+        end
+
+        it '#word_cached? returns false if the word is not in the dictionary' do
+          expect(word_results.word_cached?).to eq false
+        end
+
+        it '#word_cached? returns true 2nd-nth time the word was searched if invalid words are being cached by any metadata processing' do
+          dictionary.word_results(word)
+          expect(word_results.word_cached?).to eq true
+        end
+      end
+    end
+  end
+end