LittleWeasel 3.0.3 → 5.0.0

data/spec/lib/LittleWeasel/preprocessors/word_preprocessors_validatable_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Preprocessors::WordPreprocessorsValidatable, type: :module do
+  subject { MockSubject.new }
+
+  WordPreprocessorsValidatable = described_class
+
+  class MockSubject
+    include WordPreprocessorsValidatable
+  end
+
+  subject { MockSubject.new }
+
+  class MockWordPreprocessor < LittleWeasel::Preprocessors::WordPreprocessor
+    def initialize(order: 0)
+      super order: order
+      self.preprocessor_on = preprocessor_on
+    end
+
+    class << self
+      def preprocess(word) [true, "#{word}-0"]; end
+    end
+  end
+
+  #.validate_word_preprocessors
+  describe '.validate_word_preprocessors' do
+    context 'when passing a blank Array' do
+      it 'passes validaton' do
+        expect { WordPreprocessorsValidatable.validate_word_preprocessors(word_preprocessors: []) }.to_not raise_error
+      end
+    end
+
+    context 'when passing a an Array with valid word preprocessors' do
+      it 'passes validation' do
+        expect { WordPreprocessorsValidatable.validate_word_preprocessors(word_preprocessors: [MockWordPreprocessor.new]) }.to_not raise_error
+      end
+    end
+
+    context 'when passing an INVALID argument' do
+      context 'when passing an invalid Array' do
+        it 'raises an error' do
+          expect { WordPreprocessorsValidatable.validate_word_preprocessors(word_preprocessors: :not_an_array) }.to raise_error(/Argument word_preprocessors is not an Array/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,444 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Services::DictionaryCacheService do
+  include_context 'dictionary cache'
+  include_context 'dictionary keys'
+  include_context 'dictionary sourceable'
+
+  subject { create(:dictionary_cache_service, 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(:file_minus_ext) { key }
+  let(:dictionary_cache) { {} }
+  let!(:initialized_dictionary_cache) { LittleWeasel::Modules::DictionaryCacheKeys.initialize_dictionary_cache(dictionary_cache: {}) }
+
+  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 eq expected_dictionary_cache
+    end
+  end
+
+  describe 'class methods' do
+    #.init
+    describe '.init' do
+      subject! { create(:dictionary_cache_service, dictionary_file_source: true, dictionary_cache: dictionary_cache) }
+
+      before do
+        create(:dictionary_cache_service, dictionary_file_source: true, dictionary_cache: dictionary_cache, dictionary_key: en_gb_dictionary_key)
+      end
+
+      it 'resets the cache to an initiaized state for all keys in the cache' do
+        expect { described_class.init(dictionary_cache: dictionary_cache) }.to change { dictionary_cache }.to(initialized_dictionary_cache)
+      end
+
+      describe 'maintains dictionary_cache object integrity' do
+        it_behaves_like 'the dictionary_cache object reference has not changed' do
+          before { subject }
+          let(:actual_dictionary_cache) { described_class.init(dictionary_cache: dictionary_cache) }
+          let(:expected_dictionary_cache) { dictionary_cache }
+        end
+      end
+    end
+
+    #.init?
+    describe '.init?' do
+      context 'when passing an initialized dictionary cache Hash' do
+        it 'returns true' do
+          expect(described_class.init? dictionary_cache: initialized_dictionary_cache).to eq true
+        end
+      end
+
+      context 'when passing a NON-initialized dictionary cache Hash' do
+        before do
+          subject.add_dictionary_source dictionary_source: file
+        end
+
+        it 'returns false' do
+          expect(described_class.init? dictionary_cache: dictionary_cache).to eq false
+        end
+      end
+    end
+
+    #.count
+    describe '.count' do
+      context 'when there are no dictionary references' do
+        subject { create(:dictionary_cache_service) }
+
+        it 'returns 0' do
+          expect(described_class.count(dictionary_cache: subject.dictionary_cache)).to eq 0
+        end
+      end
+
+      context 'when there are are dictionary references' do
+        subject { create(:dictionary_cache_service, dictionary_file_source: true) }
+
+        it 'returns the dictionary reference count' do
+          expect(described_class.count(dictionary_cache: subject.dictionary_cache)).to eq 1
+        end
+      end
+    end
+  end
+
+  #init
+  describe '#init' do
+    subject! { create(:dictionary_cache_service, dictionary_file_source: true, dictionary_cache: dictionary_cache) }
+
+    let!(:subject2) { create(:dictionary_cache_service, dictionary_file_source: true, dictionary_cache: dictionary_cache, dictionary_key: en_gb_dictionary_key) }
+    let!(:original_dictionary_cache) { dictionary_cache }
+
+    it 'resets the cache to an initiaized state for the GIVEN KEY ONLY' do
+      expect { subject.init }.to change { dictionary_cache }.from(original_dictionary_cache).to(subject2.dictionary_cache)
+      expect { subject2.init }.to change { dictionary_cache }.from(original_dictionary_cache).to(subject.dictionary_cache)
+    end
+
+    describe 'maintains dictionary_cache object integrity' do
+      it_behaves_like 'the dictionary_cache object reference has not changed' do
+        let(:actual_dictionary_cache) { subject.init.dictionary_cache }
+        let(:expected_dictionary_cache) { dictionary_cache }
+      end
+    end
+  end
+
+  #dictionary_reference?
+  describe '#dictionary_reference?' do
+    subject { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_file_source: true, dictionary_cache: dictionary_cache) }
+
+    context 'when the dictionary reference exists' do
+      it 'returns true' do
+        expect(subject.dictionary_reference?).to eq true
+      end
+    end
+
+    context 'when the dictionary reference DOES NOT exist' do
+      subject { create(:dictionary_cache_service, dictionary_key: es_es_dictionary_key, dictionary_cache: dictionary_cache) }
+
+      before do
+        create(:dictionary_cache_service, dictionary_key: en_us_dictionary_key, dictionary_cache: dictionary_cache)
+          .add_dictionary_source dictionary_source: memory_source
+        create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: dictionary_cache)
+          .add_dictionary_source dictionary_source: dictionary_path_for(file_name: en_gb_dictionary_key.key)
+      end
+
+      it 'returns false' do
+        expect(subject.dictionary_reference?).to eq false
+      end
+    end
+
+    describe 'maintains dictionary_cache object integrity' do
+      it_behaves_like 'the dictionary_cache object reference has not changed' do
+        let(:actual_dictionary_cache) { subject.dictionary_cache }
+        let(:expected_dictionary_cache) { dictionary_cache }
+      end
+    end
+  end
+
+  #add_dictionary_source dictionary_source: memory_source
+  describe '#add_dictionary_source dictionary_source: memory_source' do
+    subject! do
+      create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key)
+        .add_dictionary_source dictionary_source: memory_source
+    end
+
+    context 'when a dictionary already exists' do
+      it 'raises an error' do
+        expect do
+          create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: subject.dictionary_cache)
+            .add_dictionary_source dictionary_source: memory_source
+        end.to raise_error "The dictionary source associated with key '#{key}' already exists."
+      end
+    end
+
+    context 'when a dictionary reference for the key DOES NOT already exist' do
+      let(:dictionary_cache_service) do
+        create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: subject.dictionary_cache)
+      end
+
+      before do
+        dictionary_cache_service.add_dictionary_source dictionary_source: memory_source
+      end
+
+      let(:dictionary_source) { dictionary_cache_service.dictionary_source }
+
+      it 'creates a new dictionary reference' do
+        expect(dictionary_cache_service.dictionary_reference?).to eq true
+      end
+
+      it 'creates a unique memory source' do
+        expect(LittleWeasel::Modules::DictionarySourceable.memory_source? dictionary_source).to be_truthy
+        expect(dictionary_source == subject.dictionary_source).to_not eq true
+      end
+    end
+
+    describe 'maintains dictionary_cache object integrity' do
+      it_behaves_like 'the dictionary_cache object reference has not changed' do
+        subject { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache) }
+        let(:actual_dictionary_cache) { subject.add_dictionary_source(dictionary_source: memory_source).dictionary_cache }
+        let(:expected_dictionary_cache) { dictionary_cache }
+      end
+    end
+  end
+
+  #add_dictionary_source
+  describe '#add_dictionary_source' do
+    context 'when a dictionary reference for the key already exists' do
+      before do
+        create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key)
+          .add_dictionary_source(dictionary_source: file)
+      end
+
+      it 'raises an error' do
+        expect do
+          create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key, dictionary_cache: subject.dictionary_cache)
+            .add_dictionary_source(dictionary_source: file)
+        end.to raise_error "The dictionary source associated with key '#{key}' already exists."
+      end
+    end
+
+    context 'when a dictionary reference for the key DOES NOT already exist' do
+      subject! do
+        create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key)
+          .add_dictionary_source(dictionary_source: file)
+      end
+
+      let(:en_gb_file) do
+        "#{ dictionary_path_for(file_name: en_gb_dictionary_key.key) }"
+      end
+
+      it 'creates a new dictionary reference' do
+        dictionary_cache_service = create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: subject.dictionary_cache)
+        dictionary_cache_service.add_dictionary_source dictionary_source: en_gb_file
+        expect(dictionary_cache_service.dictionary_reference?).to eq true
+      end
+
+      context 'when the file source already exists' do
+        it 'reuses the existing file source' do
+          dictionary_cache_service = create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: subject.dictionary_cache)
+          # Note: We're using the same file as en-US dictionary key, so
+          # the file source is NOT unique and will be reused.
+          dictionary_cache_service.add_dictionary_source dictionary_source: file
+          expect(LittleWeasel::Modules::DictionarySourceable.file_source? dictionary_cache_service.dictionary_source).to be_truthy
+          expect(dictionary_cache_service.dictionary_source == subject.dictionary_source).to eq true
+        end
+      end
+
+      context 'when the file source DOES NOT already exists' do
+        it 'creates a unique file source' do
+          dictionary_cache_service = create(:dictionary_cache_service, dictionary_key: en_gb_dictionary_key, dictionary_cache: subject.dictionary_cache)
+          # Note: We're using file that is DIFFERENT from the file being used by the
+          # en-US dictionary key, the file source created will be unique.
+          dictionary_cache_service.add_dictionary_source dictionary_source: en_gb_file
+          expect(LittleWeasel::Modules::DictionarySourceable.file_source? dictionary_cache_service.dictionary_source).to be_truthy
+          expect(dictionary_cache_service.dictionary_source == subject.dictionary_source).to eq false
+        end
+      end
+    end
+
+    describe 'maintains dictionary_cache object integrity' do
+      it_behaves_like 'the dictionary_cache object reference has not changed' do
+        subject { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache) }
+        let(:actual_dictionary_cache) { subject.add_dictionary_source(dictionary_source: file).dictionary_cache }
+        let(:expected_dictionary_cache) { dictionary_cache }
+      end
+    end
+  end
+
+  #dictionary_file
+  describe '#dictionary_file' do
+    context 'when a file source is used' do
+      subject! { create(:dictionary_cache_service, dictionary_key: dictionary_key).add_dictionary_source(dictionary_source: file) }
+
+      it 'returns the dictionary file' do
+        expect(subject.dictionary_file).to eq file
+      end
+    end
+
+    context 'when a memory source is used' do
+      subject! { create(:dictionary_cache_service, dictionary_key: dictionary_key).add_dictionary_source dictionary_source: memory_source }
+
+      let(:dictionary_words) { dictionary_words_for(dictionary_file_path: file) }
+
+      it 'returns the dictionary file' do
+        expect(LittleWeasel::Modules::DictionarySourceable.memory_source? subject.dictionary_file).to be_truthy
+      end
+    end
+  end
+
+  #dictionary_id
+  describe '#dictionary_id' do
+    context 'when a dictionary id exists for the given dictionary key' do
+      before do
+        subject.add_dictionary_source dictionary_source: memory_source
+      end
+
+      it 'returns the key' do
+        expect(subject.dictionary_id).to_not be_nil
+      end
+    end
+
+    context 'when a dictionary id DOES NOT exist for the given dictionary key' do
+      it 'returns nil' do
+        expect(subject.dictionary_id).to be_nil
+      end
+    end
+  end
+
+  #dictionary_id!
+  describe '#dictionary_id!' do
+    context 'when a dictionary id associated with the dictionary key exists' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key, dictionary_file_source: true) }
+
+      it 'returns the dictionary id' do
+        expect { subject.dictionary_id! }.to_not raise_error
+      end
+    end
+
+    context 'when a dictionary id associated with the dictionary key DOES NOT exist' do
+      subject { create(:dictionary_cache_service) }
+
+      it 'raises an error' do
+        expect { subject.dictionary_id! }.to raise_error "A dictionary id could not be found for key '#{key}'."
+      end
+    end
+  end
+
+  #dictionary_exist?
+  describe '#dictionary_exist?' do
+    context 'when the dictionary reference does not exist' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache) }
+
+      it 'returns false' do
+        expect(subject.dictionary_exist?).to eq false
+      end
+    end
+
+    context 'when the dictionary is already loaded' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_file_source: true, load: true) }
+
+      it 'returns true' do
+        expect(subject.dictionary_exist?).to eq true
+      end
+    end
+
+    context 'when the dictionary is NOT already loaded' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_file_source: true) }
+
+      it 'returns false' do
+        expect(subject.dictionary_exist?).to eq false
+      end
+    end
+  end
+
+  #dictionary_object
+  describe '#dictionary_object' do
+    context 'when the dictionary object is already cached/loaded' do
+      subject { create(:dictionary_cache_service, dictionary_file_source: true, load: true) }
+
+      it 'returns the dictionary object' do
+        expect(subject.dictionary_object).to be_kind_of LittleWeasel::Dictionary
+      end
+    end
+
+    context 'when the dictionary object is NOT already cached/loaded' do
+      context 'when the dictionary reference exists' do
+        it 'returns an object that is not present?' do
+          expect(create(:dictionary_cache_service, dictionary_file_source: true).dictionary_object).to_not be_present
+        end
+      end
+
+      context 'when the dictionary reference DOES NOT exist' do
+        it 'returns an object that is not present?' do
+          expect(create(:dictionary_cache_service).dictionary_object).to_not be_present
+        end
+      end
+    end
+  end
+
+  #dictionary_object!
+  describe '#dictionary_object!' do
+    describe 'when the dictionary is NOT in the cache' do
+      it 'raises an error' do
+        expect { subject.dictionary_object! }.to raise_error("The dictionary object associated with argument key '#{key}' is not in the cache.")
+      end
+    end
+
+    describe 'when the dictionary is loaded/cached' do
+      subject { create(:dictionary_cache_service, dictionary_file_source: true, load: true) }
+
+      it 'returns the dictionary cache for the dictionary' do
+        expect(subject.dictionary_reference?).to eq true
+        expect(subject.dictionary_exist?).to eq true
+        expect(subject.dictionary_object!).to be_kind_of LittleWeasel::Dictionary
+      end
+    end
+  end
+
+  #dictionary_object=
+  describe '#dictionary_object=' do
+    context 'when the dictionary object passed is invalid' do
+      subject { create(:dictionary_cache_service) }
+
+      context 'when nil' do
+        it 'raises an error' do
+          expect { subject.dictionary_object = nil }.to raise_error 'Argument object is not a Dictionary object'
+        end
+      end
+
+      context 'when not a Dictionary object' do
+        it 'raises an error' do
+          expect { subject.dictionary_object = :wrong_object }.to raise_error 'Argument object is not a Dictionary object'
+        end
+      end
+    end
+
+    context 'when there is NO dictionary reference' do
+      before do
+        allow(dictionary_object).to receive(:is_a?).and_return(true)
+      end
+
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key) }
+
+      let(:dictionary_object) { Object.new }
+
+      it 'raises an error' do
+        expect { subject.dictionary_object = dictionary_object }.to raise_error "The dictionary reference associated with key '#{key}' could not be found."
+      end
+    end
+
+    context 'when the dictionary is already loaded/cached and different from the dictionary object passed' do
+      subject { create(:dictionary_cache_service, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key, dictionary_file_source: true, load: true) }
+
+      let(:dictionary) { create(:dictionary, dictionary_cache: dictionary_cache, dictionary_key: dictionary_key) }
+
+      it 'raises an error' do
+        expect { subject.dictionary_object = dictionary }.to raise_error  "The dictionary is already loaded/cached for key '#{key}'; use #unload or #kill first."
+      end
+    end
+
+    context 'when the dictionary is already loaded/cached and the dictionary object is the same as the one that is loaded/cached' do
+      subject { create(:dictionary_cache_service, dictionary_file_source: true, load: true) }
+
+      it 'returns the same object' do
+        expect(subject.dictionary_object = subject.dictionary_object).to eq subject.dictionary_object
+      end
+    end
+
+    context 'when the dictionary is NOT already loaded/cached' do
+      subject { create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_file_source: true) }
+
+      let(:dictionary) { create(:dictionary, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache) }
+
+      it 'updates the dictionary object' do
+        expect { subject.dictionary_object = dictionary }.to_not raise_error
+        expect(subject.dictionary_object).to eq dictionary
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Services::DictionaryCreatorService do
+  include_context 'dictionary keys'
+  include_context 'mock word filters'
+  include_context 'mock word preprocessors'
+
+  subject { create(:dictionary_creator_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_metadata: dictionary_metadata, word_filters: word_filters, word_preprocessors: word_preprocessors) }
+
+  let(:language) { :en }
+  let(:region) { :us }
+  let(:tag) {}
+  let(:dictionary_key) { create(:dictionary_key, language: language, region: region, tag: tag) }
+  let(:key) { dictionary_key.key }
+  let(:file) { dictionary_path_for(file_name: key) }
+  let(:dictionary_cache) { {} }
+  let(:dictionary_metadata) { {} }
+  let(:word_filters) {}
+  let(:word_preprocessors) {}
+
+  shared_examples 'it should' do
+    context 'with word_filters' do
+      context 'when argument word_filters contains word filters' do
+        let(:word_filters) do
+          [
+            DollarSignFilter.new,
+            LittleWeasel::Filters::EnUs::NumericFilter.new,
+            LittleWeasel::Filters::EnUs::SingleCharacterWordFilter.new
+          ]
+        end
+
+        it 'creates a dictionary with the word filters passed' do
+          expect(dictionary).to be_kind_of LittleWeasel::Dictionary
+          expect(dictionary.word_results('$').success?).to eq true
+          expect(dictionary.word_results('1000').success?).to eq true
+          expect(dictionary.word_results('A').success?).to eq true
+        end
+      end
+    end
+
+    context 'with NO word_filters' do
+      context 'when argument word_filters is an empty Array' do
+        let(:word_filters) { [] }
+
+        it 'creates a dictionary that uses no word filters' do
+          expect(dictionary).to be_kind_of LittleWeasel::Dictionary
+          expect(dictionary.word_filters).to be_blank
+        end
+      end
+
+      context 'when argument word_filters is nil' do
+        let(:word_filters) {}
+
+        it 'creates a dictionary that uses no word filters' do
+          expect(dictionary).to be_kind_of LittleWeasel::Dictionary
+          expect(dictionary.word_filters).to be_blank
+        end
+      end
+    end
+
+    context 'with word_preprocessors' do
+      let(:word_preprocessors) { [UpcaseWordPreprocessor.new(order: 0)] }
+      let(:word) { 'a' }
+
+      context 'when argument word_preprocessors contains word preprocessors' do
+        it 'creates a dictionary with the word preprocessors passed' do
+          expect(dictionary).to be_kind_of LittleWeasel::Dictionary
+          preprocessed_words = dictionary.word_results(word).preprocessed_words
+          expect(preprocessed_words.original_word).to eq word
+          expect(preprocessed_words.preprocessed_words.count).to eq 1
+          expect(preprocessed_words.preprocessed_words[0].original_word).to eq word
+          expect(preprocessed_words.preprocessed_words[0].preprocessed_word).to eq word.upcase
+          expect(preprocessed_words.preprocessed_words[0].preprocessor).to eq word_preprocessors[0].to_sym
+          expect(preprocessed_words.preprocessed_words[0].preprocessed).to eq true
+          expect(preprocessed_words.preprocessed_words[0].preprocessor_order).to eq word_preprocessors[0].order
+        end
+      end
+    end
+
+    context 'with NO word_preprocessors' do
+      context 'when argument word_preprocessors is an empty Array' do
+        let(:word_preprocessors) { [] }
+
+        it 'creates a dictionary that uses no word preprocessors' do
+          expect(dictionary).to be_kind_of LittleWeasel::Dictionary
+          expect(dictionary.word_preprocessors).to be_blank
+        end
+      end
+
+      context 'when argument word_preprocessors is nil' do
+        let(:word_preprocessors) {}
+
+        it 'creates a dictionary that uses no word preprocessors' do
+          expect(dictionary).to be_kind_of LittleWeasel::Dictionary
+          expect(dictionary.word_preprocessors).to be_blank
+        end
+      end
+    end
+  end
+
+  #from_file_source
+  describe '#from_file_source' do
+    let(:dictionary) { subject.from_file_source file: file }
+
+    it_behaves_like 'it should'
+  end
+
+  #from_memory_source
+  describe '#from_memory_source' do
+    let(:dictionary) { subject.from_memory_source dictionary_words: dictionary_words }
+    let(:dictionary_words) do
+      dictionary_words_for dictionary_file_path: file
+    end
+
+    it_behaves_like 'it should'
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LittleWeasel::Services::DictionaryFileLoaderService do
+  include_context 'dictionary cache'
+
+  subject! { create(:dictionary_file_loader_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache) }
+
+  before(:each) do
+    LittleWeasel::Services::DictionaryCacheService.init dictionary_cache: dictionary_cache
+  end
+
+  let(:dictionary_key) { create(:dictionary_key, language: :en, region: :us) }
+  let(:key) { dictionary_key.key }
+  let(:dictionary_cache) { {} }
+
+  #execute
+  describe '#execute' do
+    context 'when the dictionary is already loaded/cached' do
+      before do
+        create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_file_source: true, load: true)
+      end
+
+      it 'raises an error' do
+        expect { subject.execute }.to raise_error "The dictionary associated with key '#{key}' already exists."
+      end
+    end
+
+    context 'when the dictionary is NOT already loaded/cached' do
+      before do
+        create(:dictionary_cache_service, dictionary_key: dictionary_key, dictionary_cache: dictionary_cache, dictionary_file_source: true)
+      end
+
+      let(:expected_key) { create(:dictionary_key, language: :en, region: :us).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
+        expect(key).to eq expected_key
+        expect(subject.execute).to eq expected_results
+      end
+    end
+  end
+end