Lint: Fix RSpec context wording (#1188)

Author: sunny

.rubocop_todo.yml

@@ -125,7 +125,7 @@ def to_s
       end
     end
 
-    context "after reset!" do
+    context "when after reset!" do
       it "clears the iso_numeric cache" do
         expect(described_class.find_by_iso_numeric(840)).to eq described_class.new(:usd)
 

spec/currency_spec.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 RSpec.describe Money::Allocation do
-  context 'given number as argument' do
+  context 'when given number as argument' do
     it 'raises an error when invalid argument is given' do
       expect { described_class.generate(100, 0) }.to raise_error(ArgumentError)
       expect { described_class.generate(100, -1) }.to raise_error(ArgumentError)
     end
 
-    context 'whole amounts' do
+    context 'with whole amounts' do
       it 'returns the amount when 1 is given' do
         expect(described_class.generate(100, 1)).to eq([100])
       end
@@ -26,7 +26,7 @@
       end
     end
 
-    context 'fractional amounts' do
+    context 'with fractional amounts' do
       it 'returns the amount when 1 is given' do
         expect(described_class.generate(BigDecimal(100), 1, false)).to eq([BigDecimal(100)])
       end
@@ -61,12 +61,12 @@
     end
   end
 
-  describe 'given array as argument' do
+  context 'when given array as argument' do
     it 'raises an error when invalid argument is given' do
       expect { described_class.generate(100, []) }.to raise_error(ArgumentError)
     end
 
-    context 'whole amounts' do
+    context 'with whole amounts' do
       it 'returns the amount when array contains only one element' do
         expect(described_class.generate(100, [1])).to eq([100])
         expect(described_class.generate(100, [5])).to eq([100])
@@ -96,7 +96,7 @@
       end
     end
 
-    context 'fractional amounts' do
+    context 'with fractional amounts' do
       it 'returns the amount when array contains only one element' do
         expect(described_class.generate(BigDecimal(100), [1], false)).to eq([100])
         expect(described_class.generate(BigDecimal(100), [5], false)).to eq([100])
@@ -137,7 +137,7 @@
     end
   end
 
-  describe 'an allocation seen in the wild' do
+  context 'with an allocation seen in the wild' do
     it 'allocates the full amount' do
       amount = 700273
       allocations = [1.1818583143661, 1.1818583143661, 1.1818583143661, 1.1818583143661, 1.1818583143661, 1.1818583143661, 1.1818583143661, 1.170126087450276, 1.0, 1.0, 1.0, 1.0]

spec/money/allocation_spec.rb

@@ -360,7 +360,7 @@
       expect(special_money_class.new(10_00, "USD") / 2).to be_a special_money_class
     end
 
-    context 'rounding preference' do
+    describe 'rounding preference' do
       before do
         allow(Money).to receive(:rounding_mode).and_return(rounding_mode)
       end
@@ -369,31 +369,31 @@
         allow(Money).to receive(:rounding_mode).and_call_original
       end
 
-      context 'ceiling rounding' do
+      context 'when ceiling rounding' do
         let(:rounding_mode) { BigDecimal::ROUND_CEILING }
 
         it "obeys the rounding preference" do
           expect(Money.new(10) / 3).to eq Money.new(4)
         end
       end
 
-      context 'floor rounding' do
+      context 'when floor rounding' do
         let(:rounding_mode) { BigDecimal::ROUND_FLOOR }
 
         it "obeys the rounding preference" do
           expect(Money.new(10) / 6).to eq Money.new(1)
         end
       end
 
-      context 'half up rounding' do
+      context 'when half up rounding' do
         let(:rounding_mode) { BigDecimal::ROUND_HALF_UP }
 
         it "obeys the rounding preference" do
           expect(Money.new(10) / 4).to eq Money.new(3)
         end
       end
 
-      context 'half down rounding' do
+      context 'when half down rounding' do
         let(:rounding_mode) { BigDecimal::ROUND_HALF_DOWN }
 
         it "obeys the rounding preference" do
@@ -851,14 +851,14 @@
           Money.default_bank = @old_default_bank
         end
 
-        context 'and other is money with different currency' do
+        context 'when other is money with different currency' do
           let(:other) { Money.gbp(1) }
 
           it 'raises Money::Bank::DifferentCurrencyError' do
             expect { instance.send(op, other) }.to raise_error Money::Bank::DifferentCurrencyError
           end
 
-          context 'even for zero' do
+          context 'when zero' do
             let(:instance) { Money.usd(0) }
             let(:other) { Money.gbp(0) }
 

spec/money/arithmetic_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-RSpec.describe Money, "formatting" do
+# rubocop:disable RSpec/DescribeClass
+RSpec.describe "Money formatting" do
   context "without i18n" do
     subject(:money) { Money.empty("USD") }
 
@@ -108,12 +109,12 @@
       expect(Money.zero.format(:display_free)).to eq('free')
     end
 
-    context "Locale :ja" do
+    context "when in Japanese" do
       before { @_locale = I18n.locale; I18n.locale = :ja }
 
       after  { I18n.locale = @_locale }
 
-      it "formats Japanese currency in Japanese properly" do
+      it "formats Japanese currency properly" do
         money = Money.new(1000, "JPY")
         expect(money.format).to eq "¥1,000"
         expect(money.format(format: "%n%u", symbol: "円")).to eq "1,000円"
@@ -218,10 +219,8 @@
         Money.default_formatting_rules = nil
       end
 
-      context 'acknowledges provided rule' do
-        it 'acknowledges provided rule' do
-          expect(Money.new(100, 'USD').format(with_currency: true)).to eq '$1.00 USD'
-        end
+      it 'acknowledges provided rule' do
+        expect(Money.new(100, 'USD').format(with_currency: true)).to eq '$1.00 USD'
       end
     end
 
@@ -460,7 +459,7 @@
         expect(Money.new(100000, "ZWD").format).to eq "$1,000.00"
       end
 
-      context "currency locale_backend i18n", :locale_backend_currency do
+      context "with a currency locale_backend i18n", :locale_backend_currency do
         it "respects explicit overriding of thousands_separator/delimiter when decimal_mark/separator collide and there's no decimal component for currencies that have no subunit" do
           expect(Money.new(300_000, 'ISK').format(thousands_separator: ",", decimal_mark: '.')).to eq "300,000 kr."
         end
@@ -641,7 +640,7 @@
     end
   end
 
-  context "custom currencies with 4 decimal places" do
+  context "with custom currencies with 4 decimal places" do
     let(:bar) do
       {
         priority: 1,
@@ -716,66 +715,78 @@
     end
   end
 
-  context "currencies with ambiguous signs" do
-    it "returns ambiguous signs when disambiguate is not set" do
-      expect(Money.new(1999_98, "USD").format).to eq("$1,999.98")
-      expect(Money.new(1999_98, "CAD").format).to eq("$1,999.98")
-      expect(Money.new(1999_98, "DKK").format).to eq("1.999,98 kr.")
-      expect(Money.new(1999_98, "NOK").format).to eq("1.999,98 kr")
-      expect(Money.new(1999_98, "SEK").format).to eq("1 999,98 kr")
-      expect(Money.new(1999_98, "BCH").format).to eq("0.00199998 ₿")
-      expect(Money.new(1999_98, "USDC").format).to eq("0.199998 USDC")
-    end
-
-    it "returns ambiguous signs when disambiguate is false" do
-      expect(Money.new(1999_98, "USD").format(disambiguate: false)).to eq("$1,999.98")
-      expect(Money.new(1999_98, "CAD").format(disambiguate: false)).to eq("$1,999.98")
-      expect(Money.new(1999_98, "DKK").format(disambiguate: false)).to eq("1.999,98 kr.")
-      expect(Money.new(1999_98, "NOK").format(disambiguate: false)).to eq("1.999,98 kr")
-      expect(Money.new(1999_98, "SEK").format(disambiguate: false)).to eq("1 999,98 kr")
-      expect(Money.new(1999_98, "BCH").format(disambiguate: false)).to eq("0.00199998 ₿")
-      expect(Money.new(1999_98, "USDC").format(disambiguate: false)).to eq("0.199998 USDC")
-    end
-
-    it "returns disambiguate signs when disambiguate: true" do
-      expect(Money.new(1999_98, "USD").format(disambiguate: true)).to eq("US$1,999.98")
-      expect(Money.new(1999_98, "CAD").format(disambiguate: true)).to eq("C$1,999.98")
-      expect(Money.new(1999_98, "DKK").format(disambiguate: true)).to eq("1.999,98 DKK")
-      expect(Money.new(1999_98, "NOK").format(disambiguate: true)).to eq("1.999,98 NOK")
-      expect(Money.new(1999_98, "SEK").format(disambiguate: true)).to eq("1 999,98 SEK")
-      expect(Money.new(1999_98, "BCH").format(disambiguate: true)).to eq("0.00199998 ₿CH")
-      expect(Money.new(1999_98, "USDC").format(disambiguate: true)).to eq("0.199998 USDC")
-    end
-
-    it "returns disambiguate signs when disambiguate: true and symbol: true" do
-      expect(Money.new(1999_98, "USD").format(disambiguate: true, symbol: true)).to eq("US$1,999.98")
-      expect(Money.new(1999_98, "CAD").format(disambiguate: true, symbol: true)).to eq("C$1,999.98")
-      expect(Money.new(1999_98, "DKK").format(disambiguate: true, symbol: true)).to eq("1.999,98 DKK")
-      expect(Money.new(1999_98, "NOK").format(disambiguate: true, symbol: true)).to eq("1.999,98 NOK")
-      expect(Money.new(1999_98, "SEK").format(disambiguate: true, symbol: true)).to eq("1 999,98 SEK")
-      expect(Money.new(1999_98, "BCH").format(disambiguate: true, symbol: true)).to eq("0.00199998 ₿CH")
-      expect(Money.new(1999_98, "USDC").format(disambiguate: true, symbol: true)).to eq("0.199998 USDC")
-    end
-
-    it "returns no signs when disambiguate: true and symbol: false" do
-      expect(Money.new(1999_98, "USD").format(disambiguate: true, symbol: false)).to eq("1,999.98")
-      expect(Money.new(1999_98, "CAD").format(disambiguate: true, symbol: false)).to eq("1,999.98")
-      expect(Money.new(1999_98, "DKK").format(disambiguate: true, symbol: false)).to eq("1.999,98")
-      expect(Money.new(1999_98, "NOK").format(disambiguate: true, symbol: false)).to eq("1.999,98")
-      expect(Money.new(1999_98, "SEK").format(disambiguate: true, symbol: false)).to eq("1 999,98")
-      expect(Money.new(1999_98, "BCH").format(disambiguate: true, symbol: false)).to eq("0.00199998")
-      expect(Money.new(1999_98, "USDC").format(disambiguate: true, symbol: false)).to eq("0.199998")
-    end
-
-    it "nevers return an ambiguous format with disambiguate: true" do
-      formatted_results = {}
-
-      # When we format the same amount in all known currencies, disambiguate should return
-      # all different values
-      Money::Currency.all.each do |currency|
-        format = Money.new(1999_98, currency).format(disambiguate: true)
-        expect(formatted_results.keys).not_to include(format), "Format '#{format}' for #{currency} is ambiguous with currency #{formatted_results[format]}."
-        formatted_results[format] = currency
+  context "with currencies with ambiguous signs" do
+    context "when disambiguate is not set" do
+      it "returns ambiguous signs" do
+        expect(Money.new(1999_98, "USD").format).to eq("$1,999.98")
+        expect(Money.new(1999_98, "CAD").format).to eq("$1,999.98")
+        expect(Money.new(1999_98, "DKK").format).to eq("1.999,98 kr.")
+        expect(Money.new(1999_98, "NOK").format).to eq("1.999,98 kr")
+        expect(Money.new(1999_98, "SEK").format).to eq("1 999,98 kr")
+        expect(Money.new(1999_98, "BCH").format).to eq("0.00199998 ₿")
+        expect(Money.new(1999_98, "USDC").format).to eq("0.199998 USDC")
+      end
+    end
+
+    context "when disambiguate is false" do
+      it "returns ambiguous signs" do
+        expect(Money.new(1999_98, "USD").format(disambiguate: false)).to eq("$1,999.98")
+        expect(Money.new(1999_98, "CAD").format(disambiguate: false)).to eq("$1,999.98")
+        expect(Money.new(1999_98, "DKK").format(disambiguate: false)).to eq("1.999,98 kr.")
+        expect(Money.new(1999_98, "NOK").format(disambiguate: false)).to eq("1.999,98 kr")
+        expect(Money.new(1999_98, "SEK").format(disambiguate: false)).to eq("1 999,98 kr")
+        expect(Money.new(1999_98, "BCH").format(disambiguate: false)).to eq("0.00199998 ₿")
+        expect(Money.new(1999_98, "USDC").format(disambiguate: false)).to eq("0.199998 USDC")
+      end
+    end
+
+    context "when disambiguate is true" do
+      it "returns disambiguous signs" do
+        expect(Money.new(1999_98, "USD").format(disambiguate: true)).to eq("US$1,999.98")
+        expect(Money.new(1999_98, "CAD").format(disambiguate: true)).to eq("C$1,999.98")
+        expect(Money.new(1999_98, "DKK").format(disambiguate: true)).to eq("1.999,98 DKK")
+        expect(Money.new(1999_98, "NOK").format(disambiguate: true)).to eq("1.999,98 NOK")
+        expect(Money.new(1999_98, "SEK").format(disambiguate: true)).to eq("1 999,98 SEK")
+        expect(Money.new(1999_98, "BCH").format(disambiguate: true)).to eq("0.00199998 ₿CH")
+        expect(Money.new(1999_98, "USDC").format(disambiguate: true)).to eq("0.199998 USDC")
+      end
+
+      it "nevers returns an ambiguous format" do
+        formatted_results = {}
+
+        # When we format the same amount in all known currencies, disambiguate
+        # should return all different values
+        Money::Currency.all.each do |currency|
+          format = Money.new(1999_98, currency).format(disambiguate: true)
+          expect(formatted_results.keys)
+            .not_to include(format),
+                    "Format '#{format}' for #{currency} is ambiguous with currency #{formatted_results[format]}."
+          formatted_results[format] = currency
+        end
+      end
+    end
+
+    context "when disambiguate is true and symbol is true" do
+      it "returns disambiguate signs" do
+        expect(Money.new(1999_98, "USD").format(disambiguate: true, symbol: true)).to eq("US$1,999.98")
+        expect(Money.new(1999_98, "CAD").format(disambiguate: true, symbol: true)).to eq("C$1,999.98")
+        expect(Money.new(1999_98, "DKK").format(disambiguate: true, symbol: true)).to eq("1.999,98 DKK")
+        expect(Money.new(1999_98, "NOK").format(disambiguate: true, symbol: true)).to eq("1.999,98 NOK")
+        expect(Money.new(1999_98, "SEK").format(disambiguate: true, symbol: true)).to eq("1 999,98 SEK")
+        expect(Money.new(1999_98, "BCH").format(disambiguate: true, symbol: true)).to eq("0.00199998 ₿CH")
+        expect(Money.new(1999_98, "USDC").format(disambiguate: true, symbol: true)).to eq("0.199998 USDC")
+      end
+    end
+
+    context "when disambiguate is true and symbol is false" do
+      it "returns no signs" do
+        expect(Money.new(1999_98, "USD").format(disambiguate: true, symbol: false)).to eq("1,999.98")
+        expect(Money.new(1999_98, "CAD").format(disambiguate: true, symbol: false)).to eq("1,999.98")
+        expect(Money.new(1999_98, "DKK").format(disambiguate: true, symbol: false)).to eq("1.999,98")
+        expect(Money.new(1999_98, "NOK").format(disambiguate: true, symbol: false)).to eq("1.999,98")
+        expect(Money.new(1999_98, "SEK").format(disambiguate: true, symbol: false)).to eq("1 999,98")
+        expect(Money.new(1999_98, "BCH").format(disambiguate: true, symbol: false)).to eq("0.00199998")
+        expect(Money.new(1999_98, "USDC").format(disambiguate: true, symbol: false)).to eq("0.199998")
       end
     end
 
@@ -802,3 +813,4 @@
     end
   end
 end
+# rubocop:enable RSpec/DescribeClass