dugway 1.0.14 → 1.2.0

data/spec/units/dugway/liquid/drops/translations_drop_spec.rb

@@ -0,0 +1,292 @@
+require 'spec_helper'
+
+describe Dugway::Drops::TranslationsDrop do
+  let(:settings) { {} }
+  let(:definitions) { {} }
+  let(:drop) { Dugway::Drops::TranslationsDrop.new(settings, definitions) }
+
+  before(:all) do
+    # Store original I18n settings to restore them later
+    @original_i18n_load_path = I18n.load_path.dup
+    @original_i18n_available_locales = I18n.config.available_locales.dup
+    @original_i18n_default_locale = I18n.default_locale
+    @original_i18n_locale = I18n.locale
+
+    # Create a unique temporary directory for theme-specific locale files for this test run
+    @theme_parent_dir = File.expand_path("../../../../tmp/translations_drop_spec_#{Time.now.to_f}", __FILE__)
+    @theme_source_dir = File.join(@theme_parent_dir, 'source') # For Dugway.source_dir mock
+    @theme_locales_dir = File.join(@theme_parent_dir, '_dugway_locales') # Theme locale files go here
+
+    FileUtils.mkdir_p(@theme_source_dir)
+    FileUtils.mkdir_p(@theme_locales_dir)
+
+    # Write theme-specific test files. These will override or supplement gem locales.
+    # Using 'navigation.cart' as a key that exists in actual gem locales (e.g., storefront.en-US.yml)
+    # and 'farewell' as a theme-only key.
+    # We use 'en-US' for the theme file to directly override the gem's 'en-US' translations.
+    File.write(File.join(@theme_locales_dir, 'storefront.en-US.yml'), <<~YAML)
+      en-US:
+        storefront:
+          navigation:
+            cart: "Theme Cart" # Override gem's "Cart"
+          farewell: "Goodbye Theme" # Theme-only
+    YAML
+    File.write(File.join(@theme_locales_dir, 'storefront.fr.yml'), <<~YAML)
+      fr:
+        storefront:
+          navigation:
+            cart: "Panier du Thème"
+    YAML
+
+    # Force load gem locales first (mimicking initial gem load)
+    # The main lib/dugway.rb (required via spec_helper) should have already configured
+    # I18n.load_path and I18n.config.available_locales with the gem's actual files.
+    # We are capturing this initial state and then augmenting it for theme-specific test files.
+
+    @theme_locale_files = Dir.glob(File.join(@theme_locales_dir, 'storefront.*.yml'))
+    
+    # Augment the load path: original gem paths + new theme paths.
+    # Theme files are added last so their definitions override gem's if keys conflict.
+    I18n.load_path = (@original_i18n_load_path + @theme_locale_files).uniq
+    
+    # Augment available locales: original gem locales + new theme locales.
+    theme_locale_codes = @theme_locale_files.map do |file|
+      name = File.basename(file, '.yml')
+      locale_code = name.match(/^storefront\.(.+)$/)&.captures&.first
+      locale_code&.to_sym
+    end.compact
+    
+    current_available_locales = (@original_i18n_available_locales.to_a + theme_locale_codes).uniq
+    
+    if current_available_locales.any? { |loc| loc.to_s.start_with?('en-') } && !current_available_locales.include?(:en)
+      current_available_locales << :en
+    end
+    
+    I18n.config.available_locales = current_available_locales
+
+    # Force a clean slate for translations before reloading.
+    # This ensures that the load path order is strictly respected for overrides.
+    I18n.backend.send(:init_translations) if I18n.backend.respond_to?(:init_translations, true)
+    
+    # Reload the backend to process all files in the (now augmented) I18n.load_path
+    # and to recognize all locales in I18n.config.available_locales.
+    I18n.backend.reload!
+    
+    # Verify that :'en-US' (which should come from the gem's original setup) is recognized.
+    # If this fails, it means :'en-US' was not in @original_i18n_available_locales or was lost.
+    unless I18n.config.available_locales.include?(:'en-US') && I18n.backend.available_locales.include?(:'en-US')
+      error_message = "I18n Setup Issue: :en-US is not available after setup.\n"
+      error_message += "I18n.config.available_locales: #{I18n.config.available_locales.inspect}\n"
+      error_message += "I18n.backend.available_locales: #{I18n.backend.available_locales.inspect}\n"
+      error_message += "I18n.load_path: #{I18n.load_path.inspect}\n"
+      error_message += "@original_i18n_available_locales: #{@original_i18n_available_locales.inspect}\n"
+      error_message += "@original_i18n_load_path: #{@original_i18n_load_path.inspect}"
+      raise error_message
+    end
+    
+    I18n.default_locale = :'en-US'
+    I18n.locale = :'en-US'
+  end
+
+  after(:all) do
+    # Clean up temporary theme directory
+    FileUtils.rm_rf(@theme_parent_dir)
+
+    # Restore original I18n settings
+    I18n.load_path = @original_i18n_load_path
+    I18n.config.available_locales = @original_i18n_available_locales
+    I18n.default_locale = @original_i18n_default_locale
+    I18n.locale = @original_i18n_locale
+    I18n.backend.reload!
+  end
+  let(:logger_double) { double('Logger', warn: nil) }
+
+  before(:each) do
+    allow(Dugway).to receive(:gem_root).and_return(File.expand_path('../../../../../', __FILE__))
+    allow(Dugway).to receive(:source_dir).and_return(@theme_source_dir)
+
+    allow(Dugway).to receive(:logger).and_return(logger_double)
+  end
+
+  describe 'Automatic Mode (Default)' do
+    context "with default language ('en-US', falling back to 'en' for theme)" do
+      # These tests rely on I18n.locale being 'en-US' (set in before(:all))
+      # The theme provides 'storefront.en.yml'
+      it "returns theme override for a key also in gem locales" do
+        # Gem 'en-US' (locales/storefront.en-US.yml) has storefront.navigation.cart: "Cart"
+        # Theme 'en' (temporary file) has storefront.navigation.cart: "Theme Cart"
+        expect(drop['navigation.cart']).to eq('Theme Cart')
+      end
+
+      it "returns theme-only translation if present" do
+        # 'farewell' is only in the temporary theme 'en' file
+        expect(drop['farewell']).to eq('Goodbye Theme')
+      end
+
+      it "returns gem translation if not in theme" do
+        # 'navigation.all_products' is in gem 'en-US.yml', not in our test theme 'en.yml'
+        # The value from locales/storefront.en-US.yml is "All products"
+        expect(drop['navigation.all_products']).to eq('All products')
+      end
+
+      it "returns missing translation message for unknown key" do
+        expect(drop['unknown.key']).to eq('[MISSING TRANSLATION: unknown.key]')
+      end
+
+      it "logs a warning for missing translation with the correct locale" do
+        expect(Dugway.logger).to receive(:warn).with("Missing translation: key='unknown.key.again' locale='en-US' mode='automatic'")
+        drop['unknown.key.again']
+      end
+    end
+
+    context "with specified locale ('fr')" do
+      let(:settings) { { translation_locale: 'fr' } }
+
+      it "returns translation for the specified language from theme" do
+        # Theme 'fr' (temporary file) has storefront.navigation.cart: "Panier du Thème"
+        expect(drop['navigation.cart']).to eq('Panier du Thème')
+      end
+
+      it "returns missing translation message if key not found in specified language (and not in fallbacks)" do
+        # 'farewell' is not in theme 'fr.yml' or any 'fr' gem locale
+        expect(drop['farewell']).to eq('[MISSING TRANSLATION: farewell]')
+      end
+      
+      it "returns gem translation if key not found in specified theme language but exists in gem's version of that language" do
+        # Assuming 'locales/storefront.fr-FR.yml' (loaded by gem) has 'navigation.all': 'Tous'
+        # and our temporary theme 'fr.yml' does not have 'navigation.all'
+        # This test depends on the content of the actual gem's fr-FR file.
+        # For a more robust test, ensure 'locales/storefront.fr-FR.yml' has 'navigation: { all: "Tous" }'
+        # Or, if 'fr-FR' is not a primary test target, this test could be more generic or skipped.
+        # For now, let's assume 'navigation.all' exists in a loaded 'fr' variant from the gem.
+        # If 'locales/storefront.fr-FR.yml' exists and is loaded:
+        # expect(drop['navigation.all']).to eq(I18n.t('storefront.navigation.all', locale: :fr))
+        # If not, it will be missing. Let's test for missing if not in theme 'fr'.
+        expect(drop['navigation.all_products']).to eq('[MISSING TRANSLATION: navigation.all_products]')
+      end
+
+      it "logs a warning with the correct locale" do
+        expect(Dugway.logger).to receive(:warn).with("Missing translation: key='farewell.again' locale='fr' mode='automatic'")
+        drop['farewell.again']
+      end
+    end
+
+    context "with specified non-existent locale ('xx')" do
+      let(:settings) { { translation_locale: 'xx' } }
+
+      it "returns missing translation message for a known key" do
+        expect(drop['navigation.cart']).to eq('[MISSING TRANSLATION: navigation.cart]')
+      end
+    end
+  end
+
+  describe 'Manual Mode' do
+    let(:settings) do
+      {
+        translation_mode: 'manual',
+        greeting_tr_text: 'Hello Manual',
+        'nested_message_tr_text' => 'Manual Nested',
+        farewell_tr_text: '',
+        explicit_nil_tr_text: nil
+      }
+    end
+
+    it "returns translation from manual setting (symbol key)" do
+      expect(drop['greeting']).to eq('Hello Manual')
+    end
+
+    it "returns translation from manual setting (string key)" do
+      # Note: The drop converts the lookup key 'nested.message' to :nested_message_tr_text
+      # but the settings hash might have string keys from JSON parsing.
+      # The drop implementation checks both symbol and string keys in the settings hash.
+      expect(drop['nested.message']).to eq('Manual Nested')
+    end
+
+    it "falls back to automatic translation if manual setting is blank and allow_blank is false (default)" do
+      # No definition provided, so allow_blank defaults to false
+      # 'farewell' exists in theme 'en' locale (storefront.en.yml created by test)
+      # I18n.locale is 'en-US'. The drop will use this locale.
+      expect(I18n).to receive(:t).with('storefront.farewell', locale: 'en-US', default: nil).and_call_original
+      expect(drop['farewell']).to eq('Goodbye Theme')
+    end
+
+    it "returns missing translation message if manual setting is explicitly nil" do
+      # If the key exists in manual settings but the value is nil, treat it as missing.
+      expect(drop['explicit_nil']).to eq('[MISSING TRANSLATION: explicit_nil]')
+    end
+
+    it "returns missing translation message if manual setting is not present" do
+      expect(drop['unknown.key']).to eq('[MISSING TRANSLATION: unknown.key]')
+    end
+
+    it "logs a warning for missing translation (manual mode)" do
+      # Expect a call to the stubbed logger
+      expect(Dugway.logger).to receive(:warn).with("Missing translation: key='unknown.key.manual' mode='manual'")
+      drop['unknown.key.manual']
+    end
+
+    it "does not use I18n backend if a valid manual setting is found" do
+      expect(I18n).not_to receive(:t)
+      expect(drop['greeting']).to eq('Hello Manual') # Uses manual setting
+    end
+
+    it "uses I18n backend if manual setting is blank and allow_blank is false" do
+      expect(I18n).to receive(:t).with('storefront.farewell', locale: 'en-US', default: nil).and_call_original
+      drop['farewell'] # Trigger lookup for blank, disallowed value
+    end
+
+    it "uses I18n backend if manual setting key is not found" do
+      expect(I18n).to receive(:t).with('storefront.unknown.key', locale: 'en-US', default: nil).and_call_original
+      drop['unknown.key'] # Trigger lookup for missing key
+    end
+
+    context "with allow_blank definitions" do
+      let(:definitions) do
+        {
+          'options' => [
+            { 'variable' => 'allow_blank_true_tr_text', 'allow_blank' => true },
+            { 'variable' => 'allow_blank_false_tr_text', 'allow_blank' => false },
+            { 'variable' => 'allow_blank_missing_tr_text' }, # allow_blank defaults to false
+            { 'variable' => 'allow_blank_non_blank_val_tr_text', 'allow_blank' => false }
+          ]
+        }
+      end
+      let(:settings) do
+        {
+          translation_mode: 'manual',
+          allow_blank_true_tr_text: '',
+          allow_blank_false_tr_text: '',
+          allow_blank_missing_tr_text: '',
+          allow_blank_non_blank_val_tr_text: 'Not Blank'
+        }
+      end
+
+      it "returns blank string when allow_blank is true" do
+        expect(drop['allow_blank_true']).to eq('')
+      end
+
+      it "falls back to automatic translation when allow_blank is false" do
+        # Assuming 'allow_blank_false' doesn't exist in automatic translations
+        expect(I18n).to receive(:t).with('storefront.allow_blank_false', locale: 'en-US', default: nil).and_return(nil)
+        expect(drop['allow_blank_false']).to eq('[MISSING TRANSLATION: allow_blank_false]')
+      end
+
+      it "falls back to automatic translation when allow_blank is missing (defaults to false)" do
+        # Assuming 'allow_blank_missing' doesn't exist in automatic translations
+        expect(I18n).to receive(:t).with('storefront.allow_blank_missing', locale: 'en-US', default: nil).and_return(nil)
+        expect(drop['allow_blank_missing']).to eq('[MISSING TRANSLATION: allow_blank_missing]')
+      end
+
+      it "returns non-blank value even when allow_blank is false" do
+        expect(drop['allow_blank_non_blank_val']).to eq('Not Blank')
+      end
+    end
+  end
+
+  describe '#derive_manual_setting_key' do
+    # Test the private method indirectly via its usage or directly if needed
+    it 'converts dot notation to underscore symbol notation' do
+      expect(drop.send(:derive_manual_setting_key, 'some.key.name')).to eq(:some_key_name_tr_text)
+    end
+  end
+end

data/spec/units/dugway/store_spec.rb

@@ -189,4 +189,41 @@ describe Dugway::Store do
       store.locale.should == 'en-US'
     end
   end
+
+  describe "#website" do
+    context "when website is provided in store_options" do
+      let(:store_options) { { website: 'https://my-custom-override.com' } }
+      let(:store) { Dugway::Store.new('dugway', store_options) }
+
+      it "returns the website from store_options" do
+        store.website.should == 'https://my-custom-override.com'
+      end
+    end
+
+    context "when website is not in store_options but in account data" do
+      let(:store) { Dugway::Store.new('dugway', {}) } # No override
+
+      before do
+        # Mock the account data to include a website
+        allow(store).to receive(:account).and_return({ 'website' => 'https://api-provided-site.com' })
+      end
+
+      it "returns the website from account data" do
+        store.website.should == 'https://api-provided-site.com'
+      end
+    end
+
+    context "when website is in neither store_options nor account data" do
+      let(:store) { Dugway::Store.new('dugway', {}) } # No override
+
+      before do
+        # Mock the account data to NOT include a website
+        allow(store).to receive(:account).and_return({})
+      end
+
+      it "returns nil" do
+        store.website.should be_nil
+      end
+    end
+  end
 end