LittleWeasel 3.0.3 → 5.0.0

data/spec/lib/LittleWeasel/services/dictionary_metadata_service_spec.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Services::DictionaryMetadataService do
+  include_context 'dictionary cache'
+  include_context 'dictionary keys'
+
+  subject { create(:dictionary_metadata_service, dictionary_key: dictionary_key, dictionary_metadata: dictionary_metadata, dictionary_cache: dictionary_cache) }
+
+  let(:en_us_dictionary_key) { dictionary_key_for(language: :en, region: :us) }
+  let(:en_gb_dictionary_key) { dictionary_key_for(language: :en, region: :gb) }
+  let(:es_es_dictionary_key) { dictionary_key_for(language: :es, region: :es) }
+
+  let(:dictionary_key) { en_us_dictionary_key }
+  let(:key) { dictionary_key.key }
+  let(:file) { dictionary_path_for(file_name: key) }
+  let(:dictionary_cache) { {} }
+  let(:metadata_key) { :metadata_key }
+  let(:dictionary_metadata) do
+    {
+      0 => { metadata_key => :metadata_object0 },
+      1 => { metadata_key1: :metadata_object1 }
+    }
+  end
+
+  shared_examples 'the dictionary_metadata object reference has not changed' do
+    it 'the dictionary_metadata object has not changed' do
+      expect(actual_dictionary_metadata).to be expected_dictionary_metadata
+    end
+  end
+
+  shared_examples 'the dictionary_cache object reference has not changed' do
+    it 'the dictionary_cache object has not changed' do
+      expect(actual_dictionary_cache).to be expected_dictionary_cache
+    end
+  end
+
+  describe 'class methods' do
+    #.init
+    describe '.init' do
+      context 'with a valid dictionary metadata argument' do
+        it 'initializes the dictionary metadata' do
+          expect(described_class.init(dictionary_metadata: dictionary_metadata)).to eq({})
+        end
+
+        it_behaves_like 'the dictionary_metadata object reference has not changed' do
+          let(:expected_dictionary_metadata) { dictionary_metadata }
+          let(:actual_dictionary_metadata) { subject.dictionary_metadata }
+        end
+      end
+
+      context 'with an INVALID dictionary metadata argument' do
+        subject { described_class.init(dictionary_metadata: dictionary_metadata) }
+
+        it_behaves_like 'the dictionary_metadata is invalid'
+      end
+    end
+
+    #.init?
+    describe '.init?' do
+      context 'with a valid dictionary metadata argument' do
+        context 'when the dictionary metadata is in an initialized state' do
+          let(:dictionary_metadata) { {} }
+
+          it 'returns true' do
+            expect(described_class.init?(dictionary_metadata: dictionary_metadata)).to eq true
+          end
+        end
+
+        context 'when the dictionary metadata is NOT in an initialized state' do
+          it 'returns false' do
+            expect(described_class.init?(dictionary_metadata: dictionary_metadata)).to eq false
+          end
+        end
+      end
+
+      context 'with an INVALID dictionary metadata argument' do
+        subject { described_class.init?(dictionary_metadata: dictionary_metadata) }
+
+        it_behaves_like 'the dictionary_metadata is invalid'
+      end
+    end
+  end
+
+  #.new
+  describe '.new' do
+    context 'when the arguments are valid' do
+      it 'instantiates without errors' do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    it_behaves_like 'the dictionary_key is invalid'
+    it_behaves_like 'the dictionary_cache is invalid'
+    it_behaves_like 'the dictionary_metadata is invalid'
+  end
+
+  #init
+  describe '#init' do
+    let(:expected_dictionary_metadata) do
+      {
+        0 => { :metadata_key=>nil },
+        1 => { metadata_key1: :metadata_object1 }
+      }
+    end
+
+    context 'when the dictionary_id is valid' do
+      before do
+        allow(subject).to receive(:dictionary_id!).and_return(0)
+      end
+
+      it 'initializes the metadata associated with the dictionary id for the given metadata_key' do
+        expect(subject.get_dictionary_metadata(metadata_key: metadata_key)).to eq dictionary_metadata.dig(0, metadata_key)
+        subject.init(metadata_key: metadata_key)
+        expect(subject.get_dictionary_metadata(metadata_key: metadata_key)).to be_nil
+        expect(dictionary_metadata).to eq expected_dictionary_metadata
+      end
+
+      it_behaves_like 'the dictionary_metadata object reference has not changed' do
+        let(:expected_dictionary_metadata) { dictionary_metadata }
+        let(:actual_dictionary_metadata) { subject.dictionary_metadata }
+      end
+
+      it_behaves_like 'the dictionary_cache object reference has not changed' do
+        let(:expected_dictionary_cache) { dictionary_cache }
+        let(:actual_dictionary_cache) { subject.dictionary_cache_service.dictionary_cache }
+      end
+    end
+
+    context 'when the dictionary_id is INVALID' do
+      it 'raises an error' do
+        expect { subject.init(metadata_key: metadata_key) }.to raise_error "A dictionary id could not be found for key '#{key}'."
+      end
+    end
+  end
+
+  #dictionary_metadata?
+  describe '#dictionary_metadata?' do
+    before do
+      allow(subject).to receive(:dictionary_id).and_return(0)
+    end
+
+    context 'when there is dictionary metadata associated with the dictionary for the metadata_key' do
+      it 'returns true' do
+        expect(subject.dictionary_metadata?(metadata_key: metadata_key)).to eq true
+      end
+    end
+
+    context 'when there is NO dictionary metadata associated with the dictionary for the metadata_key' do
+      context 'when there is no dictionary metadata for the dictionary_id' do
+        let(:dictionary_metadata) do
+          {
+            99 => { metadata_key => :metadata_object }
+          }
+        end
+
+        it 'returns false' do
+          expect(subject.dictionary_metadata?(metadata_key: metadata_key)).to eq false
+        end
+      end
+
+      context 'when there is no dictionary metadata for the metadata_key' do
+        let(:dictionary_metadata) do
+          {
+            0 => { :wrong_metadata_key => :metadata_object }
+          }
+        end
+
+        it 'returns false' do
+          expect(subject.dictionary_metadata?(metadata_key: metadata_key)).to eq false
+        end
+      end
+
+      context 'when the dictionary metadata for the metadata_key is not present' do
+        let(:dictionary_metadata) do
+          {
+            0 => { metadata_key => nil }
+          }
+        end
+
+        it 'returns false' do
+          expect(subject.dictionary_metadata?(metadata_key: metadata_key)).to eq false
+        end
+      end
+    end
+  end
+
+  #get_dictionary_metadata
+  describe '#get_dictionary_metadata' do
+    before do
+      allow(subject).to receive(:dictionary_id!).and_return(0)
+    end
+
+    context 'when there is no dictionary_id found in the dictionary metadata associated with the dictionary key' do
+      before do
+        allow(subject).to receive(:dictionary_id!).and_call_original
+      end
+
+      it 'raises an error' do
+        expect { subject.get_dictionary_metadata(metadata_key: metadata_key) }.to raise_error "A dictionary id could not be found for key '#{key}'."
+      end
+    end
+
+    context 'when there is dictionary metadata associated with the dictionary for the metadata_key' do
+      it 'returns true' do
+        expect(subject.get_dictionary_metadata(metadata_key: metadata_key)).to eq :metadata_object0
+      end
+    end
+
+    context 'when there is NO dictionary metadata associated with the dictionary for the metadata_key' do
+      context 'when there is no dictionary metadata for the dictionary_id' do
+        let(:dictionary_metadata) do
+          {
+            99 => { metadata_key => :metadata_object0 }
+          }
+        end
+
+        it 'returns false' do
+          expect(subject.get_dictionary_metadata(metadata_key: metadata_key)).to eq nil
+        end
+      end
+
+      context 'when there is no dictionary metadata for the metadata_key' do
+        let(:dictionary_metadata) do
+          {
+            0 => { :wrong_metadata_key => :metadata_object0 }
+          }
+        end
+
+        it 'returns false' do
+          expect(subject.get_dictionary_metadata(metadata_key: metadata_key)).to eq nil
+        end
+      end
+
+      context 'when the dictionary metadata for the metadata_key is not present' do
+        let(:dictionary_metadata) do
+          {
+            0 => { metadata_key => nil }
+          }
+        end
+
+        it 'returns false' do
+          expect(subject.get_dictionary_metadata(metadata_key: metadata_key)).to eq nil
+        end
+      end
+    end
+  end
+
+  #set_dictionary_metadata
+  describe '#set_dictionary_metadata' do
+    before do
+      allow(subject).to receive(:dictionary_id!).and_return(0)
+    end
+
+    let(:new_metadata_object) { :new_metadata_object0 }
+
+    context 'when passing valid arguments' do
+      it 'returns self' do
+        expect(subject.set_dictionary_metadata(value: new_metadata_object, metadata_key: metadata_key)).to be subject
+      end
+
+      it 'sets the dictionary metadata value' do
+        subject.set_dictionary_metadata(value: new_metadata_object, metadata_key: metadata_key)
+        expect(subject.get_dictionary_metadata(metadata_key: metadata_key)).to eq new_metadata_object
+      end
+    end
+
+    context 'when there is no dictionary_id found in the dictionary metadata associated with the dictionary key' do
+      before do
+        allow(subject).to receive(:dictionary_id!).and_call_original
+      end
+
+      it 'raises an error' do
+        expect { subject.get_dictionary_metadata(metadata_key: metadata_key) }.to raise_error "A dictionary id could not be found for key '#{key}'."
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/word_results_spec.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::WordResults do
+  subject do
+    create(:word_results,
+      original_word: original_word,
+      filters_matched: filters_matched,
+      preprocessed_words: preprocessed_words,
+      word_cached: word_cached,
+      word_valid: word_valid)
+  end
+
+  let(:original_word) { 'original-word' }
+  let(:word) { original_word }
+  let(:filters_matched) { [] }
+  let(:preprocessed_words) {}
+  let(:word_cached) { false }
+  let(:word_valid) { false }
+
+  #.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 argument original_word is invalid' do
+        let(:original_word) {}
+
+        it 'raises an error' do
+          expect { subject }.to raise_error(/Argument original_word is not a String/)
+        end
+      end
+
+      context 'when argument filters_matched is invalid' do
+        let(:filters_matched) {}
+
+        it 'raises an error' do
+          expect { subject }.to raise_error(/Argument filters_matched is not an Array/)
+        end
+      end
+
+      context 'when argument preprocessed_words is invalid' do
+        let(:preprocessed_words) { :invalid }
+
+        it 'raises an error' do
+          expect { subject }.to raise_error(/Argument preprocessed_words does not respond to/)
+        end
+      end
+
+      context 'when argument word_cached is invalid' do
+        let(:word_cached) {}
+
+        it 'raises an error' do
+          expect { subject }.to raise_error(/Argument word_cached is not true or false/)
+        end
+      end
+
+      context 'when argument word_valid is invalid' do
+        let(:word_valid) {}
+
+        it 'raises an error' do
+          expect { subject }.to raise_error(/Argument word_valid is not true or false/)
+        end
+      end
+    end
+  end
+
+  #original_word=
+  describe '#original_word=' do
+    let(:changed_value) { "#{original_word}-changed" }
+
+    it 'sets @original_word' do
+      expect(subject.original_word).to eq original_word
+      subject.original_word = changed_value
+      expect(subject.original_word).to eq changed_value
+    end
+  end
+
+  #filters_matched=
+  describe '#filters_matched=' do
+    let(:filters_matched) { [:filters_matched] }
+    let(:changed_value) { [:filters_matched_changed] }
+
+    it 'sets @filters_matched' do
+      expect(subject.filters_matched).to eq filters_matched
+      subject.filters_matched = changed_value
+      expect(subject.filters_matched).to eq changed_value
+    end
+  end
+
+  #word_cached=
+  describe '#word_cached=' do
+    let(:changed_value) { !word_cached }
+
+    it 'sets @word_cached' do
+      expect(subject.word_cached).to eq word_cached
+      subject.word_cached = changed_value
+      expect(subject.word_cached).to eq changed_value
+    end
+  end
+
+  #word_valid=
+  describe '#word_valid=' do
+    let(:changed_value) { !word_valid }
+
+    it 'sets @word_valid' do
+      expect(subject.word_valid).to eq word_valid
+      subject.word_valid = changed_value
+      expect(subject.word_valid).to eq changed_value
+    end
+  end
+
+  #preprocesed_words=
+  describe '#preprocesed_words=' do
+    let(:changed_value) do
+      create(:preprocessed_words, with_word_processors: 2, original_word: original_word)
+    end
+
+    it 'sets @preprocesed_words' do
+      expect { subject.preprocessed_words = changed_value }.to \
+        change { subject.preprocessed_words }
+        .from(preprocessed_words)
+        .to(changed_value)
+    end
+  end
+
+  #success?
+  describe '#success?' do
+    context 'when #filter_match? is false AND #word_valid? is false' do
+      before do
+        allow(subject).to receive(:filter_match?).and_return false
+        allow(subject).to receive(:word_valid?).and_return false
+      end
+
+      it 'returns false' do
+        expect(subject.success?).to be false
+      end
+    end
+
+    context 'when #filter_match? is true OR #word_valid? is true' do
+      context 'when #filter_match? is true' do
+        before do
+          allow(subject).to receive(:filter_match?).and_return true
+          allow(subject).to receive(:word_valid?).and_return false
+        end
+
+        it 'returns true' do
+          expect(subject.success?).to be true
+        end
+      end
+
+      context 'when #word_valid? is true' do
+        before do
+          allow(subject).to receive(:filter_match?).and_return false
+          allow(subject).to receive(:word_valid?).and_return true
+        end
+
+        it 'returns true' do
+          expect(subject.success?).to be true
+        end
+      end
+    end
+  end
+
+  #filter_match?
+  describe '#filter_match?' do
+    context '#when filters_matched is present' do
+      let(:filters_matched) { [:matched_filter] }
+
+      it 'returns true' do
+        expect(subject.filter_match?).to eq true
+      end
+    end
+
+    context '#when filters_matched is NOT present' do
+      it 'returns false' do
+        expect(subject.filter_match?).to eq false
+      end
+    end
+  end
+
+  #word_cached?
+  describe '#word_cached?' do
+    context '#when word_cached is true' do
+      let(:word_cached) { true }
+
+      it 'returns true' do
+        expect(subject.word_cached?).to eq true
+      end
+    end
+
+    context '#when word_cached is false' do
+      it 'returns false' do
+        expect(subject.word_cached?).to eq false
+      end
+    end
+  end
+
+  #word_valid?
+  describe '#word_valid?' do
+    context '#when word_valid is true' do
+      let(:word_valid) { true }
+
+      it 'returns true' do
+        expect(subject.word_valid?).to eq true
+      end
+    end
+
+    context '#when word_valid is false' do
+      it 'returns false' do
+        expect(subject.word_valid?).to eq false
+      end
+    end
+  end
+
+  #preprocessed_word?
+  describe '#preprocessed_word?' do
+    subject do
+      create(:word_results,
+        original_word: original_word,
+        filters_matched: [],
+        preprocessed_words: preprocessed_words,
+        word_cached: false,
+        word_valid: false)
+    end
+
+    context 'when #preprocessed_word is NOT nil' do
+      let(:preprocessed_words) do
+        create(:preprocessed_words, with_word_processors: 2)
+      end
+
+      it 'returns true' do
+        expect(subject.preprocessed_word?).to be true
+      end
+    end
+
+    context 'when #preprocessed_word is nil' do
+      let(:preprocessed_words) do
+        create(:preprocessed_words)
+      end
+
+      it 'returns false' do
+        expect(subject.preprocessed_word?).to be false
+      end
+    end
+  end
+
+  #preprocessed_word_or_original_word
+  describe '#preprocessed_word_or_original_word' do
+    let(:original_word) { 'word' }
+
+    context 'when the word has been preprocessed' do
+      let(:preprocessed_words) do
+        create(:preprocessed_words,
+          original_word: original_word,
+          with_word_processors: 2)
+      end
+
+      it 'returns #preprocesed_word' do
+        expect(subject.preprocessed_word_or_original_word).to eq 'word-0-1'
+      end
+    end
+
+    context 'when the word has NOT been preprocessed' do
+      it 'returns #original_word' do
+        expect(subject.preprocessed_word_or_original_word).to eq original_word
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/workflow/workflow_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Workflow tests' do
+  include_context 'dictionary cache'
+  include_context 'dictionary keys'
+
+  subject { LittleWeasel::DictionaryManager.new }
+
+  # This loads the BIG en-US-big dictionary
+  let(:en_us_dictionary_key) { dictionary_key_for(language: :en, region: :us, tag: :big) }
+  let(:en_gb_dictionary_key) { dictionary_key_for(language: :en, region: :gb) }
+  let(:es_es_dictionary_key) { dictionary_key_for(language: :es, region: :es) }
+
+  let(:dictionary_key) { en_us_dictionary_key }
+  let(:key) { dictionary_key.key }
+  let(:file) { dictionary_path_for(file_name: key) }
+  let(:dictionary_words) { dictionary_words_for(dictionary_file_path: file) }
+end

data/spec/spec_helper.rb

@@ -1,12 +1,123 @@
+require 'pry-byebug'
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter 'spec'
+end
+
 require File.expand_path(File.dirname(__FILE__) + '../../lib/LittleWeasel')
+Dir[File.join('.', 'spec/support/**/*.rb')].each do |f|
+  require f
+end
 
-# Use :should in stead of :expect
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :should
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end
-  config.mock_with :rspec do |c|
-    c.syntax = :should
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
   end
-  #config.raise_errors_for_deprecations!
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+
+  # Enable both should and expect until the old specs are upgraded.
+  config.expect_with :rspec do |c|
+    c.syntax = %i[should, expect]
+  end
+
+  # Load support files
+  config.include Support::FileHelpers
+  config.include Support::GeneralHelpers
+
+  config.before(:each) { LittleWeasel.configure { |config| config.reset } }
 end