dugway 1.0.14 → 1.2.0

data/spec/fixtures/theme/layout.html

@@ -70,6 +70,8 @@
     {% endif %}
 
     <section>
+      {# Added for testing page.name variable #}
+      <span data-testid="page-name-test" style="display: none;">{{ page.name }}</span>
     {% if page.category == 'custom' %}
       <h1>{{ page.name }}</h1>
       {{ page_content | paragraphs }}

data/spec/fixtures/theme/settings.json

@@ -5,11 +5,13 @@
     {
       "variable": "logo",
       "label": "Logo",
+      "section": "global_navigation",
       "description": "Good for an image up to 150 pixels wide",
       "default": "logo_bc.png"
     },
     {
       "variable": "background_image",
+      "section": "general",
       "label": "Background Image",
       "description": "Adds a repeating background image"
     }
@@ -18,6 +20,7 @@
     {
       "variable": "slideshow_images",
       "label": "Slideshow",
+      "section": "homepage",
       "description": "This is a slideshow",
       "defaults": [
         "slideshow/1.gif",
@@ -30,6 +33,7 @@
     {
       "variable": "lookbook_images",
       "label": "Lookbook",
+      "section": "general",
       "description": "This is a lookbook"
     }
   ],
@@ -133,6 +137,7 @@
     {
       "variable": "show_search",
       "label": "Show search",
+      "section": "global_navigation",
       "type": "boolean",
       "default": false,
       "description": "Shows a search field"
@@ -140,6 +145,7 @@
     {
       "variable": "fixed_sidebar",
       "label": "Fixed Sidebar",
+      "section": "global_navigation",
       "type": "boolean",
       "default": true,
       "description": "Keeps the sidebar stationary while the page scrolls"

data/spec/spec_helper.rb

@@ -10,6 +10,10 @@ RSpec.configure do |config|
   fixture_path = File.join(Dir.pwd, 'spec', 'fixtures')
 
   config.before(:each) do
+    # Stub Dugway.logger to write to /dev/null before each test
+    # This prevents log file creation/modification by the test suite.
+    allow(Dugway).to receive(:logger).and_return(Logger.new(File::NULL))
+
     # Stub api calls
     stub_request(:get, /.*api\.bigcartel\.com.*/).to_return(lambda { |request|
       { :body => File.new(File.join(fixture_path, 'store', request.uri.path.split('/', 3).last)), :status => 200, :headers => {} }

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

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe Dugway::Drops::FeaturesDrop do
+  # Define the base source data representing the top-level 'features' block
+  # expected from the store configuration (e.g., dugway.json).
+  let(:feature_source_data) do
+    {
+      'definitions' => {
+        'feature_a' => 'enabled_by_default',  # Will be tested with no override, and with opt-out
+        'feature_b' => 'disabled_by_default' # Will be tested with no override, and with opt-in
+      },
+      # Opt-in 'feature_b' to test overriding disabled default
+      # Opt-in 'feature_a' to test conflict where opt-out wins
+      'opt_ins' => ['feature_b', 'feature_a'],
+      # Opt-out 'feature_a' to test overriding enabled default and conflict
+      'opt_outs' => ['feature_a']
+    }
+  end
+
+  # Initialize the drop with the source data
+  let(:features_drop) { described_class.new(feature_source_data) }
+
+  # Note: The 'before' block setting up theme_mock is removed as we now pass source directly.
+  # BaseDrop might still require context for other things (like request/params),
+  # but it's not needed for these specific tests focused on feature logic.
+
+  describe '#feature_definitions' do
+    it 'returns the definitions from the source hash' do
+      expect(features_drop.feature_definitions).to eq(feature_source_data['definitions'])
+    end
+
+    it 'returns empty hash if definitions are missing in source' do
+      drop = described_class.new(feature_source_data.except('definitions'))
+      expect(drop.feature_definitions).to eq({})
+    end
+
+    it 'returns empty hash if source is nil' do
+      drop = described_class.new(nil)
+      expect(drop.feature_definitions).to eq({})
+    end
+
+    it 'returns empty hash if source is empty' do
+      drop = described_class.new({})
+      expect(drop.feature_definitions).to eq({})
+    end
+  end
+
+  describe '#opt_ins' do
+    it 'returns filtered opt_ins from source' do
+      # Only includes opt-ins that are also in definitions
+      expect(features_drop.opt_ins).to match_array(['feature_a', 'feature_b'])
+    end
+
+    it 'returns empty array if opt_ins are missing in source' do
+      drop = described_class.new(feature_source_data.except('opt_ins'))
+      expect(drop.opt_ins).to eq([])
+    end
+
+    it 'returns empty array if definitions are missing in source' do
+      # Because opt_ins are filtered by defined features
+      drop = described_class.new(feature_source_data.except('definitions'))
+      expect(drop.opt_ins).to eq([])
+    end
+
+    it 'returns empty array if source is nil' do
+      drop = described_class.new(nil)
+      expect(drop.opt_ins).to eq([])
+    end
+  end
+
+  describe '#opt_outs' do
+    it 'returns filtered opt_outs from source' do
+      # Only includes opt-outs that are also in definitions
+      expect(features_drop.opt_outs).to match_array(['feature_a'])
+    end
+
+    it 'returns empty array if opt_outs are missing in source' do
+      drop = described_class.new(feature_source_data.except('opt_outs'))
+      expect(drop.opt_outs).to eq([])
+    end
+
+    it 'returns empty array if definitions are missing in source' do
+      # Because opt_outs are filtered by defined features
+      drop = described_class.new(feature_source_data.except('definitions'))
+      expect(drop.opt_outs).to eq([])
+    end
+
+    it 'returns empty array if source is nil' do
+      drop = described_class.new(nil)
+      expect(drop.opt_outs).to eq([])
+    end
+  end
+
+  describe 'dynamic feature check methods' do
+    context 'when feature is enabled by default (feature_a)' do
+      it 'returns true if not opted out' do
+        source_without_opt_out = feature_source_data.merge('opt_outs' => [])
+        drop = described_class.new(source_without_opt_out)
+        expect(drop.has_feature_a?).to be true
+        expect(drop.has_feature_a).to be true
+      end
+
+      it 'returns false if opted out' do
+        expect(features_drop.has_feature_a?).to be false
+        expect(features_drop.has_feature_a).to be false
+      end
+    end
+
+    context 'when feature is disabled by default (feature_b)' do
+      it 'returns false if not opted in' do
+        source_without_opt_in = feature_source_data.merge('opt_ins' => [])
+        drop = described_class.new(source_without_opt_in)
+        expect(drop.has_feature_b?).to be false
+        expect(drop.has_feature_b).to be false
+      end
+
+      it 'returns true if opted in' do
+        expect(features_drop.has_feature_b?).to be true
+        expect(features_drop.has_feature_b).to be true
+      end
+    end
+
+    context 'with conflicting opt-in/out (feature_a)' do
+      it 'returns false because opt-out takes precedence' do
+        expect(features_drop.has_feature_a?).to be false
+        expect(features_drop.has_feature_a).to be false
+      end
+    end
+
+    context 'when feature is not defined' do
+      it 'returns false' do
+        expect(features_drop.has_undefined_feature?).to be false
+        expect(features_drop.has_undefined_feature).to be false
+      end
+    end
+
+    context 'when source data is empty' do
+      let(:empty_source) { {} }
+      let(:drop_with_empty_source) { described_class.new(empty_source) }
+
+      it 'returns false for any feature check' do
+        expect(drop_with_empty_source.has_feature_a?).to be false
+        expect(drop_with_empty_source.has_any_other_feature).to be false
+      end
+    end
+
+    context 'when source data is nil' do
+      let(:nil_source) { nil }
+      let(:drop_with_nil_source) { described_class.new(nil_source) }
+
+      it 'returns false for any feature check' do
+        expect(drop_with_nil_source.has_feature_a?).to be false
+        expect(drop_with_nil_source.has_any_other_feature).to be false
+      end
+    end
+  end
+
+  describe '#respond_to?' do
+    # NOTE: Standard Ruby behavior means respond_to? is false for methods
+    # handled by method_missing unless respond_to_missing? is also defined.
+    it 'returns false for dynamic methods' do
+      expect(features_drop.respond_to?(:has_feature_a?)).to be false
+      expect(features_drop.respond_to?('has_feature_b?')).to be false
+      expect(features_drop.respond_to?(:has_feature_a)).to be false
+      expect(features_drop.respond_to?('has_feature_b')).to be false
+    end
+
+    it 'returns false for undefined dynamic methods' do
+      expect(features_drop.respond_to?(:has_undefined_feature?)).to be false
+      expect(features_drop.respond_to?(:has_undefined_feature)).to be false
+    end
+
+    it 'returns true for existing methods' do
+      expect(features_drop.respond_to?(:opt_ins)).to be true
+      expect(features_drop.respond_to?(:source)).to be true # From BaseDrop initialization
+    end
+
+    it 'returns false for completely unknown methods' do
+      expect(features_drop.respond_to?(:some_random_method)).to be false
+    end
+  end
+end

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

@@ -3,6 +3,19 @@ require 'spec_helper'
 describe Dugway::Drops::ProductDrop do
   let(:product) { Dugway::Drops::ProductDrop.new(Dugway.store.products.first) }
 
+  let(:related_products_mock) do
+    [
+      { 'id' => 2, 'name' => 'Related Product 1' },
+      { 'id' => 3, 'name' => 'Related Product 2' }
+    ]
+  end
+
+  before do
+    allow(Dugway::Drops::RelatedProductsDrop).to receive(:new)
+      .with(product.source, limit: 5, sort_order: nil)
+      .and_return(double(products: related_products_mock))
+  end
+
   describe "#id" do
     it "should return the product's id" do
       product.id.should == 9422939
@@ -266,4 +279,27 @@ describe Dugway::Drops::ProductDrop do
       end
     end
   end
+
+  describe "#related_products" do
+    let(:theme) { double('Dugway::Theme') }
+    let(:theme_customization) do
+      {
+        'related_items' => 5,
+        'related_products_order' => 'position'
+      }
+    end
+
+    before do
+      allow(Dugway).to receive(:theme).and_return(theme)
+      allow(theme).to receive(:customization).and_return(theme_customization)
+      allow(Dugway::Drops::RelatedProductsDrop).to receive(:new)
+        .with(product.source)
+        .and_return(double(products: related_products_mock))
+    end
+
+    it "returns the related products from RelatedProductsDrop" do
+      related_products = product.related_products
+      expect(related_products).to eq(related_products_mock)
+    end
+  end
 end

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

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Dugway::Drops::RelatedProductsDrop do
+  let(:product) do
+    {
+      'id' => 1,
+      'category_ids' => [1, 2],
+      'name' => 'Sample Product'
+    }
+  end
+
+  let(:related_product_1) do
+    {
+      'id' => 2,
+      'category_ids' => [1],
+      'name' => 'Related Product 1'
+    }
+  end
+
+  let(:related_product_2) do
+    {
+      'id' => 3,
+      'category_ids' => [2],
+      'name' => 'Related Product 2'
+    }
+  end
+
+  let(:unrelated_product) do
+    {
+      'id' => 4,
+      'category_ids' => [3],
+      'name' => 'Unrelated Product'
+    }
+  end
+
+  let(:theme) { double('Dugway::Theme') }
+  let(:theme_customization) do
+    {
+      'related_items' => 2,
+      'related_products_order' => 'position'
+    }
+  end
+
+  before do
+    allow(Dugway.store).to receive(:products).and_return([
+      product,
+      related_product_1,
+      related_product_2,
+      unrelated_product
+    ])
+    allow(Dugway).to receive(:theme).and_return(theme)
+    allow(theme).to receive(:customization).and_return(theme_customization)
+  end
+
+  let(:drop) { described_class.new(product) }
+
+  describe "#products" do
+    it "returns related products within the same categories" do
+      products = drop.products
+      expect(products.map { |p| p['id'] }).to match_array([2, 3])
+    end
+
+    it "limits the number of related products returned" do
+      allow(theme).to receive(:customization).and_return({ 'related_items' => 1 })
+      products = drop.products
+      expect(products.size).to eq(1)
+    end
+
+    it "excludes the original product from the results" do
+      products = drop.products
+      expect(products.map { |p| p['id'] }).not_to include(product['id'])
+    end
+
+    it "falls back to other products if category matches are insufficient" do
+      product['category_ids'] = [] # No categories
+      products = drop.products
+      expect(products.map { |p| p['id'] }).to match_array([2, 3])
+    end
+  end
+end

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

@@ -127,4 +127,49 @@ describe Dugway::Drops::ThemeDrop do
       end
     end
   end
+
+  describe '#features' do
+    let(:mock_features_config) do
+      {
+        'definitions' => { 'feat_a' => 'enabled_by_default' },
+        'opt_ins' => [],
+        'opt_outs' => ['feat_a']
+      }
+    end
+    let(:mock_options) { { 'features' => mock_features_config } }
+
+    before do
+      # Stub the global Dugway.options for these tests
+      allow(Dugway).to receive(:options).and_return(mock_options)
+      # ThemeDrop needs context to potentially access registers, even if not used by #features itself
+      theme.context = context
+    end
+
+    it 'initializes FeaturesDrop with data from Dugway.options["features"]' do
+      features_drop_instance = theme.features # Call the method under test
+
+      expect(features_drop_instance).to be_an_instance_of(Dugway::Drops::FeaturesDrop)
+      # Verify that the source passed to FeaturesDrop was correct
+      expect(features_drop_instance.instance_variable_get(:@source)).to eq(mock_features_config)
+      # Optionally, check a derived value to ensure data was processed
+      expect(features_drop_instance.feature_definitions).to eq(mock_features_config['definitions'])
+      expect(features_drop_instance.opt_outs).to eq(['feat_a']) # Check filtering based on definitions
+    end
+
+    it 'initializes FeaturesDrop with empty hash if features key is missing in options' do
+      allow(Dugway).to receive(:options).and_return({}) # No 'features' key
+      features_drop_instance = theme.features
+      expect(features_drop_instance).to be_an_instance_of(Dugway::Drops::FeaturesDrop)
+      expect(features_drop_instance.instance_variable_get(:@source)).to eq({})
+      expect(features_drop_instance.feature_definitions).to eq({})
+    end
+
+    it 'initializes FeaturesDrop with empty hash if Dugway.options is nil' do
+      allow(Dugway).to receive(:options).and_return(nil)
+      features_drop_instance = theme.features
+      expect(features_drop_instance).to be_an_instance_of(Dugway::Drops::FeaturesDrop)
+      expect(features_drop_instance.instance_variable_get(:@source)).to eq({})
+      expect(features_drop_instance.feature_definitions).to eq({})
+    end
+  end
 end