LittleWeasel 3.0.4 → 4.0.0

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

data/spec/lib/LittleWeasel/metadata/dictionary_creator_servicable_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::DictionaryCreatorServicable, type: :module do
+  include_context 'dictionary keys'
+
+  DictionaryCreatorServicable = described_class
+
+  class SubjectMock
+    include DictionaryCreatorServicable
+    include LittleWeasel::Filters::WordFilterable
+    include LittleWeasel::Modules::DictionaryKeyable
+    include LittleWeasel::Modules::DictionaryMetadataServicable
+
+    def initialize(dictionary_key:, dictionary_cache:, dictionary_metadata:, word_filters:)
+      self.dictionary_key = dictionary_key
+      self.dictionary_cache = dictionary_cache
+      self.dictionary_metadata = dictionary_metadata
+      self.word_filters = word_filters
+    end
+  end
+
+  subject { SubjectMock.new(dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata, word_filters: word_filters) }
+
+  let(:en_us_dictionary_key) { dictionary_key_for(language: :en, region: :us) }
+  let(:dictionary_key) { en_us_dictionary_key }
+  let(:key) { dictionary_key.key }
+  let(:file) { dictionary_path_for(file_name: key) }
+  let(:dictionary_cache) { {} }
+  let(:dictionary_metadata) { {} }
+  let(:word_filters) {}
+
+  #attributes
+  describe 'attributes' do
+    it 'responds to the correct attributes' do
+      expect(subject).to respond_to(
+        :dictionary_key,
+        :dictionary_cache,
+        :word_filters)
+    end
+  end
+
+  #dictionary_creator_service
+  describe '#dictionary_creator_service' do
+    it 'responds to #dictionary_creator_service' do
+      expect(subject).to respond_to(:dictionary_creator_service)
+    end
+
+    it 'returns a Services::DictionaryCreatorService object' do
+      expect(subject.dictionary_creator_service).to be_kind_of LittleWeasel::Services::DictionaryCreatorService
+    end
+  end
+end

data/spec/lib/LittleWeasel/metadata/dictionary_metadata_spec.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Metadata::DictionaryMetadata do
+  subject { create(:dictionary_metadata, dictionary_words: dictionary_words, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata) }
+
+  let!(:dictionary_cache_service) { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_file_source: true, load: true) }
+  let!(:dictionary_metadata_service) { create(:dictionary_metadata_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata) }
+  let(:dictionary_words) { create(:dictionary_hash) }
+  let(:dictionary_key) { create(:dictionary_key) }
+  let(:dictionary_cache) { {} }
+  let(:dictionary_metadata) { {} }
+  let(:invalid_words_metadata_key) { invalid_words_metadata_class.metadata_key }
+  let(:invalid_words_metadata_class) { LittleWeasel::Metadata::InvalidWordsMetadata }
+
+  #.new
+  describe '#.new' do
+    context 'with valid arguments' do
+      it 'instantiates the object' do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context 'with invalid arguments' do
+      context 'when dictionary_words is nil' do
+        # Note: do not use the factory for this spec becasue
+        # it creates a dictionary if a nil dictionay is passed
+        # so the test will never pass if using the factory.
+        subject { described_class.new(dictionary_words: dictionary_words, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata) }
+
+        let(:dictionary_words) {}
+
+        it 'raises an error' do
+          expect { subject }.to raise_error(/Argument dictionary_words is not a Hash/)
+        end
+      end
+
+      context 'when dictionary_words is not a Hash' do
+        let(:dictionary_words) { %w(I am a bad dictionary) }
+
+        it 'raises an error' do
+          expect { subject }.to raise_error(/Argument dictionary_words is not a Hash/)
+        end
+      end
+    end
+  end
+
+  #[]
+  describe '#[]' do
+    context 'when passing a valid metadata_key' do
+      context 'when it is a key that points to a valid metadata observer' do
+        before do
+          subject.add_observers
+        end
+
+        it 'returns the metadata observer object' do
+          expect(subject[invalid_words_metadata_key]).to be_kind_of invalid_words_metadata_class
+        end
+      end
+
+      context 'when it is a key that DOES NOT point to a valid metadata observer' do
+        it 'returns nil' do
+          expect(subject[invalid_words_metadata_key]).to be_nil
+        end
+      end
+    end
+
+    context 'when passing an INVALID metadata_key' do
+      it 'returns nil' do
+        expect(subject[:bad_metadata_key]).to be_nil
+      end
+    end
+  end
+
+  #init
+  describe '#init' do
+    context 'when there are observers attached' do
+      before do
+        subject.add_observers
+      end
+
+      context 'when metadata is in the dictionary cache' do
+        it 'observers are notified to init' do
+          # Sanity check.
+          expect(subject.count_observers).to eq 1
+          expect(subject.observers[invalid_words_metadata_key]).to receive(:init)
+          subject.init
+        end
+      end
+    end
+
+    context 'when there are NO observers attached' do
+      it 'observers are NOT notified to init' do
+        # Sanity check.
+        expect(subject.count_observers).to eq 0
+        expect(subject.observers[invalid_words_metadata_key]).to_not receive(:init)
+        subject.init
+      end
+    end
+
+    context 'when dictionary metadata is already in the dictionary cache' do
+      it 'inits the metadata with what is currently in the dictionary cache' do
+      end
+    end
+  end
+
+  #refresh
+  describe '#refresh' do
+    context 'when there are observers attached' do
+      before do
+        subject.add_observers
+      end
+
+      it 'observers are notified to refresh' do
+        # Sanity check.
+        expect(subject.count_observers).to eq 1
+        expect(subject.observers[invalid_words_metadata_key]).to receive(:refresh)
+        subject.refresh
+      end
+    end
+
+    context 'when there are NO observers attached' do
+      it 'observers are NOT notified to refresh' do
+        # Sanity check.
+        expect(subject.count_observers).to eq 0
+        expect(subject.observers[invalid_words_metadata_key]).to_not receive(:refresh)
+        subject.refresh
+      end
+    end
+
+    context 'when dictionary metadata is already in the dictionary cache' do
+      it 'refreshes the metadata with what is currently in the dictionary cache' do
+      end
+    end
+  end
+
+  #delete_observer
+  describe '#delete_observer' do
+    context 'when a valid observer object is passed' do
+      before do
+        subject.add_observers
+      end
+
+      let(:observer) { subject.observers.values.first }
+
+      it 'the observer is removed from the #observers list' do
+        expect { subject.delete_observer(observer) }
+          .to change { subject.observers.count }
+          .from(1)
+          .to(0)
+      end
+    end
+
+    context 'when an INVALID observer object is passed' do
+      let(:bad_observer) { :bad_observer }
+
+      it 'raises an error' do
+        expect { subject.delete_observer(bad_observer) }.to raise_error 'Argument metadata_observable is not a ' \
+            "Metadata::MetadataObserverable object: #{bad_observer.class}"
+      end
+    end
+  end
+
+  #add_observers
+  describe '#add_observers' do
+    it 'returns the same object that was called' do
+      expect(subject.add_observers).to be subject
+    end
+
+    context 'when a metadata object is in a state to observe' do
+      it 'added as an observer' do
+        expect(subject.add_observers.count_observers).to eq 1
+      end
+
+      context 'when #add_observers is called more than once' do
+        context 'when argument force is true (force: true)' do
+          before do
+            subject.add_observers
+          end
+
+          it 'reinstantiates and replaces the observers' do
+            expect(subject.add_observers(force: true).count_observers).to eq 1
+          end
+        end
+
+        context 'when argument force is false (force: false)' do
+          before do
+            subject.add_observers
+          end
+
+          it 'raises an error' do
+            expect { subject.add_observers }.to raise_error 'Observers have already been added; use #add_observers(force: true) instead'
+          end
+        end
+      end
+    end
+
+    context 'when a metadata object is NOT in a state to observe' do
+      before do
+        allow(LittleWeasel::Metadata::InvalidWordsMetadata).to receive(:observe?).and_return(false)
+      end
+
+      it 'NOT added as an observer' do
+        expect(subject.add_observers.count_observers).to eq 0
+      end
+    end
+  end
+end