dugway 1.2.0 → 1.3.0

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

@@ -1,6 +1,12 @@
 require 'spec_helper'
 
 describe Dugway::Drops::PagesDrop do
+  before(:each) do
+    # Reset store state before each test
+    Dugway.store.instance_variable_set(:@pages, nil)
+    Dugway.store.instance_variable_set(:@external_pages, nil)
+  end
+
   let(:pages) do
     Dugway::Drops::PagesDrop.new(
       Dugway.store.pages.map do |p|
@@ -14,15 +20,58 @@ describe Dugway::Drops::PagesDrop do
     )
   end
 
+  def create_pages_with_external(external_pages_data)
+    # Mock the store before creating pages
+    allow(Dugway.store).to receive(:external_pages).and_return(external_pages_data)
+    # Clear memoized pages
+    Dugway.store.instance_variable_set(:@pages, nil)
+    
+    Dugway::Drops::PagesDrop.new(
+      Dugway.store.pages.map do |p|
+        case p["permalink"]
+        when "cart"
+          Dugway::Drops::CartDrop.new(p)
+        else
+          Dugway::Drops::PageDrop.new(p)
+        end
+      end
+    )
+  end
+
   describe "#all" do
-    it "should return an array of all pages" do
-      all = pages.all
-      all.should be_an_instance_of(Array)
-      all.size.should == 1
+    context "with only custom pages" do
+      it "should return an array of all custom pages" do
+        all = pages.all
+        all.should be_an_instance_of(Array)
+        all.size.should == 1
 
-      page = all.first
-      page.should be_an_instance_of(Dugway::Drops::PageDrop)
-      page.name.should == 'About Us'
+        page = all.first
+        page.should be_an_instance_of(Dugway::Drops::PageDrop)
+        page.name.should == 'About Us'
+      end
+    end
+
+    context "with custom and external pages" do
+      it "should return an array of all pages (custom + external)" do
+        pages_with_external = create_pages_with_external([
+          {
+            'name' => 'Subscribe',
+            'permalink' => 'subscribe',
+            'url' => 'https://example.com/subscribe',
+            'category' => 'external'
+          }
+        ])
+        
+        all = pages_with_external.all
+        all.should be_an_instance_of(Array)
+        all.size.should == 2
+
+        custom_page = all.find { |p| p.name == 'About Us' }
+        custom_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+
+        external_page = all.find { |p| p.name == 'Subscribe' }
+        external_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+      end
     end
   end
 
@@ -46,6 +95,136 @@ describe Dugway::Drops::PagesDrop do
     end
   end
 
+  describe "#subscribe_page" do
+    context "when subscribe_url is configured" do
+      it "should return the subscribe page" do
+        allow(Dugway.store).to receive(:subscribe_url).and_return('https://example.com/subscribe')
+        pages_with_subscribe = create_pages_with_external([
+          {
+            'name' => 'Subscribe',
+            'permalink' => 'subscribe',
+            'url' => 'https://example.com/subscribe',
+            'category' => 'external'
+          }
+        ])
+        
+        subscribe_page = pages_with_subscribe.subscribe_page
+        subscribe_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+        subscribe_page.name.should == 'Subscribe'
+        subscribe_page.url.should == 'https://example.com/subscribe'
+      end
+    end
+
+    context "when subscribe_url is not configured" do
+      it "should return nil" do
+        allow(Dugway.store).to receive(:subscribe_url).and_return(nil)
+        pages_without_subscribe = create_pages_with_external([])
+        
+        pages_without_subscribe.subscribe_page.should be_nil
+      end
+    end
+  end
+
+  describe "#custom_pages" do
+    it "should return an array of custom pages" do
+      custom_pages = pages.custom_pages
+      custom_pages.should be_an_instance_of(Array)
+      custom_pages.size.should == 1
+      custom_pages.first.should be_an_instance_of(Dugway::Drops::PageDrop)
+      custom_pages.first.name.should == 'About Us'
+    end
+  end
+
+  describe "#external_pages" do
+    context "when subscribe_url is configured" do
+      it "should return an array with the subscribe page" do
+        pages_with_subscribe = create_pages_with_external([
+          {
+            'name' => 'Subscribe',
+            'permalink' => 'subscribe',
+            'url' => 'https://example.com/subscribe',
+            'category' => 'external'
+          }
+        ])
+        
+        external_pages = pages_with_subscribe.external_pages
+        external_pages.should be_an_instance_of(Array)
+        external_pages.size.should == 1
+        external_pages.first.should be_an_instance_of(Dugway::Drops::PageDrop)
+        external_pages.first.name.should == 'Subscribe'
+      end
+    end
+
+    context "when subscribe_url is not configured" do
+      it "should return an empty array" do
+        pages_without_subscribe = create_pages_with_external([])
+        
+        pages_without_subscribe.external_pages.should == []
+      end
+    end
+  end
+
+  describe "#required_pages" do
+    def create_pages_with_required(required_pages_data)
+      # Mock the store before creating pages
+      allow(Dugway.store).to receive(:required_pages).and_return(required_pages_data)
+      # Clear memoized pages
+      Dugway.store.instance_variable_set(:@pages, nil)
+      
+      Dugway::Drops::PagesDrop.new(
+        Dugway.store.pages.map do |p|
+          case p["permalink"]
+          when "cart"
+            Dugway::Drops::CartDrop.new(p)
+          else
+            Dugway::Drops::PageDrop.new(p)
+          end
+        end
+      )
+    end
+
+    context "when required pages are configured" do
+      it "should return an array with the required pages" do
+        pages_with_required = create_pages_with_required([
+          {
+            'name' => 'Terms of Service',
+            'permalink' => 'terms-of-service',
+            'url' => 'https://example.com/terms',
+            'category' => 'custom',
+            'required' => true
+          },
+          {
+            'name' => 'Privacy Policy',
+            'permalink' => 'privacy-policy',
+            'url' => 'https://example.com/privacy',
+            'category' => 'custom',
+            'required' => true
+          }
+        ])
+        
+        required_pages = pages_with_required.required_pages
+        required_pages.should be_an_instance_of(Array)
+        required_pages.size.should == 2
+        
+        terms_page = required_pages.find { |p| p.name == 'Terms of Service' }
+        terms_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+        terms_page.url.should == 'https://example.com/terms'
+        
+        privacy_page = required_pages.find { |p| p.name == 'Privacy Policy' }
+        privacy_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+        privacy_page.url.should == 'https://example.com/privacy'
+      end
+    end
+
+    context "when no required pages are configured" do
+      it "should return an empty array" do
+        pages_without_required = create_pages_with_required([])
+        
+        pages_without_required.required_pages.should == []
+      end
+    end
+  end
+
   private
 
   def rendered_template(template, assigns={}, registers={})

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

@@ -302,4 +302,21 @@ describe Dugway::Drops::ProductDrop do
       expect(related_products).to eq(related_products_mock)
     end
   end
+
+  describe "#price_suffix" do
+    it "should return nil when no price_suffix is configured" do
+      allow(Dugway.store).to receive(:price_suffix).and_return(nil)
+      product.price_suffix.should be_nil
+    end
+
+    it "should return the price_suffix from store configuration" do
+      allow(Dugway.store).to receive(:price_suffix).and_return(' USD')
+      product.price_suffix.should == ' USD'
+    end
+
+    it "should return the price_suffix from store options" do
+      allow(Dugway.store).to receive(:price_suffix).and_return('+ HI')
+      product.price_suffix.should == '+ HI'
+    end
+  end
 end

data/spec/units/dugway/liquid/filters/core_filters_spec.rb

@@ -34,12 +34,251 @@ describe Dugway::Filters::CoreFilters do
     end
 
     it "should support the 'code' format argument" do
-      rendered_template("{{ 1234.56 | money: 'code' }}").should == '1,234.56 <span class="currency_code">USD</span>'
+      rendered_template("{{ 1234.56 | money: 'code' }}").should == '<span class="currency_code">USD</span>1,234.56'
     end
 
     it "should support the 'sign_and_code' format argument" do
       rendered_template("{{ 1234.56 | money: 'sign_and_code' }}").should == '<span class="currency_sign">$</span>1,234.56 <span class="currency_code">USD</span>'
     end
+
+    it "should use theme.money_format when explicitly passed as parameter" do
+      theme_drop = Dugway::Drops::ThemeDrop.new({ 'money_format' => 'sign' }, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should use theme.money_format = 'code' when explicitly passed as parameter" do
+      theme_drop = Dugway::Drops::ThemeDrop.new({ 'money_format' => 'code' }, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_code">USD</span>1,234.56'
+    end
+
+    it "should use theme.money_format = 'sign_and_code' when explicitly passed as parameter" do
+      theme_drop = Dugway::Drops::ThemeDrop.new({ 'money_format' => 'sign_and_code' }, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56 <span class="currency_code">USD</span>'
+    end
+
+    it "should use default format when no format argument is provided" do
+      theme_drop = Dugway::Drops::ThemeDrop.new({ 'money_format' => 'sign' }, {})
+      rendered_template("{{ 1234.56 | money }}", { 'theme' => theme_drop }).should == '1,234.56'
+    end
+
+    it "should fall back to default format when theme.money_format is not set" do
+      rendered_template("{{ 1234.56 | money }}").should == '1,234.56'
+    end
+
+    it "should handle money_format from dugway.json customization when explicitly passed" do
+      # Simulate how the theme would be loaded with dugway.json customization
+      customization = { 'money_format' => 'sign' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should handle money: theme.money_format syntax like storefront" do
+      # Test the exact syntax the user is using: {{ price | money: theme.money_format }}
+      customization = { 'money_format' => 'sign' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should handle money_format 'none' correctly returning just the number" do
+      customization = { 'money_format' => 'none' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '1,234.56'
+    end
+
+    it "should support the 'rounded' format argument" do
+      rendered_template("{{ 1234.56 | money: 'rounded' }}").should == '1,235'
+    end
+
+    it "should support the 'sign_rounded' format argument" do
+      rendered_template("{{ 1234.56 | money: 'sign_rounded' }}").should == '<span class="currency_sign">$</span>1,235'
+    end
+
+    it "should support the 'code_rounded' format argument" do
+      rendered_template("{{ 1234.56 | money: 'code_rounded' }}").should == '<span class="currency_code">USD</span>1,235'
+    end
+
+    it "should round up 10.99 to 11 with rounded format" do
+      rendered_template("{{ 10.99 | money: 'rounded' }}").should == '11'
+    end
+
+    it "should round up 10.99 to $11 with sign_rounded format" do
+      rendered_template("{{ 10.99 | money: 'sign_rounded' }}").should == '<span class="currency_sign">$</span>11'
+    end
+
+    it "should round up 10.99 to 11 USD with code_rounded format" do
+      rendered_template("{{ 10.99 | money: 'code_rounded' }}").should == '<span class="currency_code">USD</span>11'
+    end
+
+    it "should handle exact amounts with rounded formats" do
+      rendered_template("{{ 10.00 | money: 'rounded' }}").should == '10'
+      rendered_template("{{ 10.00 | money: 'sign_rounded' }}").should == '<span class="currency_sign">$</span>10'
+      rendered_template("{{ 10.00 | money: 'code_rounded' }}").should == '<span class="currency_code">USD</span>10'
+    end
+  end
+
+  describe "#product_price" do
+    it "should handle fixed pricing products" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price }}", { 'product' => product }).should == '1,234.56'
+    end
+
+    it "should handle fixed pricing products with format" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price: 'sign' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should handle variable pricing products with default format" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price }}", { 'product' => product }).should == '10.00 - 20.00'
+    end
+
+    it "should handle variable pricing products with sign format" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should handle variable pricing products with code format" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>10.00 - 20.00'
+    end
+
+    it "should return empty for nil product" do
+      rendered_template("{{ nil | product_price }}").should == ''
+    end
+
+    it "should fallback to price field if default_price is not present" do
+      product = { 'price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price }}", { 'product' => product }).should == '1,234.56'
+    end
+
+    it "should work with theme.money_format for fixed pricing" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      customization = { 'money_format' => 'sign' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: theme.money_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should work with theme.money_format for variable pricing" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      customization = { 'money_format' => 'sign' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: theme.money_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should handle locale-specific currency formatting" do
+      # Test that the currency code position respects locale formatting
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>10.00 - 20.00'
+    end
+
+    # Tests for range_format parameter
+    it "should show min price only when range_format is 'min_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', 'min_only' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00'
+    end
+
+    it "should show min price only with code format when range_format is 'min_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code', 'min_only' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>10.00'
+    end
+
+    it "should show max price only when range_format is 'max_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', 'max_only' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>20.00'
+    end
+
+    it "should show max price only with code format when range_format is 'max_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code', 'max_only' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>20.00'
+    end
+
+    it "should show range when range_format is 'default'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', 'default' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should show range when range_format is nil" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', nil }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should show range when range_format is an invalid value" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', 'invalid' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should show range by default when range_format is not specified" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    # Test ThemeDrop integration for real-world usage
+    it "should work with theme-based range format when 'min_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      customization = { 'price_range_format' => 'min_only' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: 'sign', theme.price_range_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>10.00'
+    end
+
+    it "should work with theme-based range format when 'max_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      customization = { 'price_range_format' => 'max_only' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: 'sign', theme.price_range_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>20.00'
+    end
+
+    it "should work with both theme.money_format and theme-based range format" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      customization = { 'money_format' => 'sign', 'price_range_format' => 'min_only' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: theme.money_format, theme.price_range_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>10.00'
+    end
+
+    # Tests for rounded formats
+    it "should handle fixed pricing products with rounded format" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price: 'rounded' }}", { 'product' => product }).should == '1,235'
+    end
+
+    it "should handle fixed pricing products with sign_rounded format" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price: 'sign_rounded' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>1,235'
+    end
+
+    it "should handle fixed pricing products with code_rounded format" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price: 'code_rounded' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>1,235'
+    end
+
+    it "should handle variable pricing products with rounded format" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'rounded' }}", { 'product' => product }).should == '11 - 21'
+    end
+
+    it "should handle variable pricing products with sign_rounded format" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign_rounded' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>11 - <span class="currency_sign">$</span>21'
+    end
+
+    it "should handle variable pricing products with code_rounded format" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code_rounded' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>11 - 21'
+    end
+
+    it "should handle rounded formats with range_format min_only" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign_rounded', 'min_only' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>11'
+    end
+
+    it "should handle rounded formats with range_format max_only" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code_rounded', 'max_only' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>21'
+    end
+
+    it "should handle exact amounts with rounded variable pricing" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign_rounded' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10 - <span class="currency_sign">$</span>20'
+    end
   end
 
   describe "#money_with_sign" do
@@ -50,7 +289,62 @@ describe Dugway::Filters::CoreFilters do
 
   describe "#money_with_code" do
     it "should convert a number to currency format with a code" do
-      rendered_template("{{ 1234.56 | money_with_code }}").should == '1,234.56 <span class="currency_code">USD</span>'
+      rendered_template("{{ 1234.56 | money_with_code }}").should == '<span class="currency_code">USD</span>1,234.56'
+    end
+
+    # Tests for different currencies to ensure locale-specific formatting
+    context "with EUR currency" do
+      # TODO: The 'eu' locale is invalid and needs to be fixed in the bigcartel-currency-locales gem.
+      # Once the gem is updated to use a valid locale like 'de-DE' for EUR, we can update these tests
+      # to expect the correct European number formatting (1.200,99 instead of 1,200.99).
+      # For now, we're expecting the fallback US formatting due to the invalid locale.
+      it "should display currency code after number with space for EUR" do
+        eur_currency = { 'sign' => '€', 'name' => 'Euro', 'id' => 4, 'code' => 'EUR', 'locale' => 'eu' }
+        # Expected: '1.200,99 <span class="currency_code">EUR</span>' once locale is fixed
+        rendered_template_with_currency("{{ 1200.99 | money_with_code }}", eur_currency).should == '1,200.99 <span class="currency_code">EUR</span>'
+      end
+
+      it "should work with money: 'code' format for EUR" do
+        eur_currency = { 'sign' => '€', 'name' => 'Euro', 'id' => 4, 'code' => 'EUR', 'locale' => 'eu' }
+        # Expected: '1.200,99 <span class="currency_code">EUR</span>' once locale is fixed
+        rendered_template_with_currency("{{ 1200.99 | money: 'code' }}", eur_currency).should == '1,200.99 <span class="currency_code">EUR</span>'
+      end
+    end
+
+    context "with CHF currency" do
+      it "should display currency code before number with space for CHF" do
+        chf_currency = { 'sign' => 'CHF', 'name' => 'Swiss Franc', 'id' => 10, 'code' => 'CHF', 'locale' => 'gsw-CH' }
+        rendered_template_with_currency("{{ 1200.99 | money_with_code }}", chf_currency).should == '<span class="currency_code">CHF</span> 1\'200.99'
+      end
+
+      it "should work with money: 'code' format for CHF" do
+        chf_currency = { 'sign' => 'CHF', 'name' => 'Swiss Franc', 'id' => 10, 'code' => 'CHF', 'locale' => 'gsw-CH' }
+        rendered_template_with_currency("{{ 1200.99 | money: 'code' }}", chf_currency).should == '<span class="currency_code">CHF</span> 1\'200.99'
+      end
+    end
+
+    context "with JPY currency" do
+      it "should display currency code before number with no decimals for JPY" do
+        jpy_currency = { 'sign' => '¥', 'name' => 'Japanese Yen', 'id' => 6, 'code' => 'JPY', 'locale' => 'ja' }
+        rendered_template_with_currency("{{ 1200.99 | money_with_code }}", jpy_currency).should == '<span class="currency_code">JPY</span>1,201'
+      end
+
+      it "should work with money: 'code' format for JPY" do
+        jpy_currency = { 'sign' => '¥', 'name' => 'Japanese Yen', 'id' => 6, 'code' => 'JPY', 'locale' => 'ja' }
+        rendered_template_with_currency("{{ 1200.99 | money: 'code' }}", jpy_currency).should == '<span class="currency_code">JPY</span>1,201'
+      end
+    end
+
+    context "with GBP currency" do
+      it "should display currency code before number with no space for GBP" do
+        gbp_currency = { 'sign' => '£', 'name' => 'Pound Sterling', 'id' => 5, 'code' => 'GBP', 'locale' => 'en-GB' }
+        rendered_template_with_currency("{{ 1200.99 | money_with_code }}", gbp_currency).should == '<span class="currency_code">GBP</span>1,200.99'
+      end
+
+      it "should work with money: 'code' format for GBP" do
+        gbp_currency = { 'sign' => '£', 'name' => 'Pound Sterling', 'id' => 5, 'code' => 'GBP', 'locale' => 'en-GB' }
+        rendered_template_with_currency("{{ 1200.99 | money: 'code' }}", gbp_currency).should == '<span class="currency_code">GBP</span>1,200.99'
+      end
     end
   end
 
@@ -63,6 +357,10 @@ describe Dugway::Filters::CoreFilters do
   private
 
   def rendered_template(template, assigns={})
-    Liquid::Template.parse(template).render(assigns, :registers => { :currency => Dugway.store.currency })
+    Liquid::Template.parse(template).render(assigns, :registers => { :currency => Dugway.store.currency, :settings => {} })
+  end
+
+  def rendered_template_with_currency(template, currency, assigns={})
+    Liquid::Template.parse(template).render(assigns, :registers => { :currency => currency, :settings => {} })
   end
 end

data/spec/units/dugway/store_spec.rb

@@ -226,4 +226,22 @@ describe Dugway::Store do
       end
     end
   end
+
+  describe "#price_suffix" do
+    context "when price_suffix is in store_options" do
+      let(:store) { Dugway::Store.new('dugway', { price_suffix: '+ HI' }) }
+
+      it "returns the price_suffix from store_options" do
+        store.price_suffix.should == '+ HI'
+      end
+    end
+
+    context "when price_suffix is not in store_options" do
+      let(:store) { Dugway::Store.new('dugway', {}) }
+
+      it "returns nil" do
+        store.price_suffix.should be_nil
+      end
+    end
+  end
 end