LittleWeasel 3.0.4 → 4.0.0

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'observer'
+
+RSpec.describe LittleWeasel::Metadata::InvalidWordsMetadata do
+  subject do
+    dictionary.dictionary_metadata_object[:invalid_words_metadata]
+  end
+
+  let(:dictionary) { dictionary_manager.create_dictionary_from_file(dictionary_key: dictionary_key, file: file) }
+  let(:dictionary_manager) { create(:dictionary_manager) }
+
+  let(:dictionary_key) { create(:dictionary_key, language: language, region: region, tag: tag) }
+  let(:language) { :en }
+  let(:region) { :us }
+  let(:tag) {}
+  let(:dictionary_cache) { {} }
+  let(:dictionary_metadata) { {} }
+  let(:file) { dictionary_path_for file_name: dictionary_key.key }
+
+  let(:dictionary_cache_service) { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache) }
+  let(:invalid_words_metadata) { described_class.new(dictionary_metadata_object: dictionary_metadata_object, dictionary_words: dictionary_words, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata) }
+  let(:dictionary_metadata_object) do
+    Class.new do
+      include Observable
+    end.new
+  end
+
+  let(:configuration) { LittleWeasel.configuration }
+
+  #new
+  describe '#new' do
+    context 'with invalid arguments' do
+      subject { invalid_words_metadata }
+
+      before do
+        dictionary_cache_service.add_dictionary_source(source: file)
+      end
+
+      context 'with invalid dictionary metadata object' do
+        let(:dictionary_words) { { 'a' => true, 'b' => true } }
+        let(:dictionary_metadata_object) { :wrong_type }
+
+        it 'raises an error' do
+          expect { subject }.to raise_error "Argument dictionary_metadata_object is not an Observable: #{dictionary_metadata_object.class}."
+        end
+      end
+
+      context 'with invalid dictionary metadata' do
+        let(:dictionary_words) { { 'a' => true, 'b' => true } }
+        let(:dictionary_metadata) { :wrong_type }
+
+        it 'raises an error' do
+          expect { subject }.to raise_error "Argument dictionary_metadata is not a valid Hash object: #{dictionary_metadata.class}"
+        end
+      end
+
+      context 'with an invalid dictionary' do
+        let(:dictionary_words) { :wrong_type }
+
+        it 'raises an error' do
+          expect { subject }.to raise_error "Argument dictionary_words is not a Hash: #{dictionary_words.class}."
+        end
+      end
+    end
+
+    context 'with a valid arguments' do
+      before do
+        subject.word_search params: { word_results: word_results1 }
+        subject.word_search params: { word_results: word_results2 }
+      end
+
+      let(:word_results1) { create(:word_results, original_word: 'badword1') }
+      let(:word_results2) { create(:word_results, original_word: 'badword2') }
+
+      it 'instantiates without error' do
+        expect { subject }.to_not raise_error
+      end
+
+      it 'initializes the necessary object attributes' do
+        expect(subject.on?).to eq true
+        expect(subject.off?).to eq false
+        expect(subject.value).to eq configuration.max_invalid_words_bytesize
+        expect(subject.value_exceeded?).to eq false
+        expect(subject.current_invalid_word_bytesize).to eq 16
+        expect(subject.cache_invalid_words?).to eq true
+      end
+    end
+
+    context 'with an invalid dictionary words Hash' do
+      subject { invalid_words_metadata }
+
+      context 'when nil' do
+        let(:dictionary_words) {}
+
+        it 'raises an error' do
+          expect { subject }.to raise_error ArgumentError
+        end
+      end
+
+      context 'when not a Hash' do
+        let(:dictionary_words) { :not_an_array }
+
+        it 'raises an error' do
+          expect { subject }.to raise_error ArgumentError
+        end
+      end
+    end
+  end
+
+  #refresh
+  describe '#refresh' do
+    it 'the metadata is refreshed' do
+      expect(subject.current_invalid_word_bytesize).to eq 0
+      expect do
+        dictionary.word_results('badword')
+        subject.refresh
+      end.to change { subject.current_invalid_word_bytesize }
+      .from(0).to(7)
+    end
+  end
+
+  #init
+  describe '#init' do
+    it 'the metadata is initialized' do
+      expect do
+        subject.dictionary_metadata_object.dictionary_words['not-found'] = false
+        subject.init
+      end.to change { subject.current_invalid_word_bytesize }
+      .from(0).to(9)
+    end
+  end
+
+  #Update
+  describe '#update' do
+    context 'with an action NOT on the whitelist' do
+      let(:action) { :bad_action! }
+      let(:params) { :params }
+
+      it 'raises an error' do
+        expect { subject.update(action, params) }.to raise_error "Argument action is not in the actions_whitelist: #{action}"
+      end
+    end
+
+    context 'with an action on the whitelist' do
+      it 'carries out the requested action' do
+        expect do
+          dictionary.word_results 'not-found'
+        end.to change { subject.current_invalid_word_bytesize }
+        .from(0).to(9)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Metadata::MetadataObserverable, type: :module do
+  MetadataObserverable = described_class
+
+  subject do
+    Class.new do
+      include MetadataObserverable
+    end.new
+  end
+
+  describe '#observe?' do
+    it 'returns false by default' do
+      expect(subject.observe?).to eq false
+    end
+  end
+
+  describe '#update' do
+    it 'raises an error if not overridden' do
+      expect { subject.update :action, args: :args }.to raise_error LittleWeasel::Errors::MustOverrideError
+    end
+  end
+
+  describe '#actions_whitelist' do
+    it 'returns an Array with :init and :refresh Symbols by default' do
+      expect(subject.actions_whitelist).to eq %i[init refresh]
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Metadata::Metadatable, type: :module do
+  Metadatable = described_class
+
+  subject do
+    Class.new do
+      include Metadatable
+
+      def update_dictionary_metadata_test
+        update_dictionary_metadata value: :value
+      end
+    end.new
+  end
+
+  describe '#init' do
+    it 'raises an error if not overridden' do
+      expect { subject.init }.to raise_error LittleWeasel::Errors::MustOverrideError
+    end
+  end
+
+  describe '#refresh' do
+    it 'raises an error if not overridden' do
+      expect { subject.refresh }.to raise_error LittleWeasel::Errors::MustOverrideError
+    end
+  end
+
+  describe '#update_dictionary_metadata' do
+    it 'raises an error if not overridden' do
+      expect { subject.update_dictionary_metadata_test }.to raise_error LittleWeasel::Errors::MustOverrideError
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/class_name_to_symbol_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::ClassNameToSymbol, type: :module do
+  ClassNameToSymbol = described_class
+
+  subject do
+    module TestModule
+      class TestMeUp
+        include ClassNameToSymbol
+      end
+    end
+  end
+
+  describe '#to_sym' do
+    it 'returns the class name as a snake-case Symbol with namespaces removed' do
+      expect(subject.new.to_sym).to eq :test_me_up
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/dictionary_file_loader_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::DictionaryFileLoader, type: :module do
+  subject do
+    dictionary_cache_service.init dictionary_cache: dictionary_cache
+    dictionary_file_loader
+  end
+
+  let(:dictionary_file_loader) do
+    Class.new do
+      include LittleWeasel::Modules::DictionaryFileLoader
+
+      attr_reader :dictionary_key, :dictionary_cache, :config
+
+      def initialize(dictionary_key, dictionary_cache)
+        self.dictionary_key = dictionary_key
+        self.dictionary_cache = dictionary_cache
+        self.config = LittleWeasel.configuration
+      end
+
+      private
+
+      attr_writer :dictionary_key, :dictionary_cache, :config
+    end.new(dictionary_key, dictionary_cache)
+  end
+
+  let(:language) { :en }
+  let(:region) { :us }
+  let(:tag) {}
+
+  let(:dictionary_cache_service) { LittleWeasel::Services::DictionaryCacheService }
+  let(:dictionary_key) { LittleWeasel::DictionaryKey.new(language: language, region: region, tag: tag) }
+  let(:key) {  dictionary_key.key }
+  let(:file) { dictionary_path_for locale: dictionary_key.locale }
+  let(:dictionary_file_key) { file }
+  let(:dictionary_cache) { {} }
+
+  #load
+  describe '#load' do
+    context 'with an invalid dictionary file' do
+      context 'when it cannot be found' do
+        let(:dictionary_path) { region_dictionary_path language: :bad, region: :worse }
+
+        it 'raises an error' do
+          expect { subject.load dictionary_path }.to raise_error LittleWeasel::Errors::DictionaryFileNotFoundError
+        end
+      end
+
+      context 'when it is empty' do
+        let(:dictionary_path) { dictionary_path_for file_name: 'empty-dictionary' }
+
+        it 'raises an error' do
+          expect { subject.load dictionary_path  }.to raise_error LittleWeasel::Errors::DictionaryFileEmptyError
+        end
+      end
+
+      context 'when it is too large' do
+        before do
+          allow(LittleWeasel.configuration).to receive(:max_dictionary_file_bytes).and_return 1
+        end
+
+        let(:dictionary_path) { language_dictionary_path language: :en }
+
+        it 'raises an error' do
+          expect { subject.load dictionary_path  }.to raise_error LittleWeasel::Errors::DictionaryFileTooLargeError
+        end
+      end
+    end
+
+    context 'with a valid dictionary file' do
+      subject { dictionary_file_loader.load dictionary_path }
+
+      let(:dictionary_path) { region_dictionary_path language: language, region: region }
+
+      context 'when the dictionary file is already loaded/cached' do
+        before { subject }
+
+        it 'does not raise an error' do
+          expect { subject }.to_not raise_error
+        end
+      end
+
+      context 'when the dictionary is NOT already loaded/cached' do
+        let(:expected_dictionary_key_key) { LittleWeasel::DictionaryKey.new(language: language, region: region, tag: tag).key }
+        let(:expected_results) do
+          ['apple',
+           'better',
+           'cat',
+           'dog',
+           'everyone',
+           'fat',
+           'game',
+           'help',
+           'italic',
+           'jasmine',
+           'kelp',
+           'love',
+           'man',
+           'nope',
+           'octopus',
+           'popeye',
+           'queue',
+           'ruby',
+           'stop',
+           'top',
+           'ultimate',
+           'very',
+           'was',
+           'xylophone',
+           'yes',
+           'zebra']
+        end
+
+        it 'returns an Array of dictionary words loaded from the file' do
+          # This test won't pass if we're not testing against an assumed
+          # dictionary file.
+          expect(dictionary_key.key).to eq expected_dictionary_key_key
+          expect(subject).to eq expected_results
+        end
+      end
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/dictionary_sourceable_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::DictionarySourceable, type: :module do
+
+  #.MEMORY_SOURCE
+  describe '::MEMORY_SOURCE' do
+    it 'returns the memory source value' do
+      expect(described_class::MEMORY_SOURCE).to eq '*'
+    end
+  end
+
+  #.memory_source
+  describe '.memory_source' do
+    it 'returns a new memory source' do
+      expect(described_class.memory_source?(described_class.memory_source)).to be_truthy
+    end
+  end
+
+  #.memory_source?
+  describe '.memory_source?' do
+    it 'returns truthy if argument is a valid memory source' do
+      expect(described_class.memory_source? '*12345678').to be_truthy
+      expect(described_class.memory_source? '*abcdef00').to be_truthy
+      expect(described_class.memory_source? '*ABCDEF00').to be_truthy
+      expect(described_class.memory_source? '*aBcDeF00').to be_truthy
+    end
+
+    it 'returns falsey if argument is NOT a memory source' do
+      expect(described_class.memory_source? '*123456789').to be_falsey
+      expect(described_class.memory_source? '*abcdefg0').to be_falsey
+      expect(described_class.memory_source? '*ABCDEFG0').to be_falsey
+      expect(described_class.memory_source? '*aBcDeFg0').to be_falsey
+      expect(described_class.memory_source? '$12345678').to be_falsey
+
+      expect(described_class.memory_source? '123456789').to be_falsey
+      expect(described_class.memory_source? 'abcdefg0').to be_falsey
+      expect(described_class.memory_source? 'ABCDEFG0').to be_falsey
+      expect(described_class.memory_source? 'aBcDeFg0').to be_falsey
+      expect(described_class.memory_source? '123456789').to be_falsey
+    end
+  end
+end

data/spec/lib/LittleWeasel/modules/language_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Modules::Language, type: :module do
+  Language = described_class
+
+  subject do
+    Class.new do
+      include Language
+
+      attr_reader :language
+
+      def initialize(language)
+        self.language = language
+      end
+
+      private
+
+      attr_writer :language
+    end.new(language)
+  end
+
+  let(:language) {}
+
+  #normalize_language
+  describe '#normalize_language' do
+    context 'with a non-nil language' do
+      context 'when passing a Symbol' do
+        let(:language) { :AbCdEfG }
+
+        it 'converts the language to a lower-case Symbol' do
+          expect(subject.normalize_language).to eq :abcdefg
+        end
+      end
+
+      context 'when passing a String' do
+        let(:language) { 'AbCdEfG' }
+
+        it 'converts the language to a lower-case String' do
+          expect(subject.normalize_language).to eq 'abcdefg'
+        end
+      end
+    end
+
+    context 'with a nil language' do
+      it 'returns nil' do
+        expect(subject.normalize_language).to be_nil
+      end
+    end
+  end
+end