ruby-measurement 1.2.0 → 1.3.0

data/spec/ruby-measurement/measurement_spec.rb

@@ -1,342 +1,416 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 
-describe Measurement do
-  subject { Measurement }
-  
+RSpec.describe Measurement do
+  subject { described_class }
+
   describe '.new' do
     describe 'with valid quantity' do
       it 'sets the quantity' do
-        subject.new(3).quantity.should eq 3
+        expect(subject.new(3).quantity).to eq 3
       end
-      
+
       it 'sets the default unit' do
-        subject.new(3).unit.should eq subject::Unit[:count]
+        expect(subject.new(3).unit).to eq subject::Unit[:count]
       end
     end
-    
+
     describe 'with valid quantity and unit name' do
       it 'sets the quantity' do
-        subject.new(2, :dozen).quantity.should eq 2
+        expect(subject.new(2, :dozen).quantity).to eq 2
       end
-      
+
       it 'sets the unit' do
-        subject.new(2, :dozen).unit.should eq subject::Unit[:dozen]
+        expect(subject.new(2, :dozen).unit).to eq subject::Unit[:dozen]
       end
     end
-    
+
     describe 'with valid quantity and unit' do
       it 'sets the quantity' do
-        subject.new(2, subject::Unit[:dozen]).quantity.should eq 2
+        expect(subject.new(2, subject::Unit[:dozen]).quantity).to eq 2
       end
-      
+
       it 'sets the unit' do
-        subject.new(2, subject::Unit[:dozen]).unit.should eq subject::Unit[:dozen]
+        expect(subject.new(2, subject::Unit[:dozen]).unit).to eq subject::Unit[:dozen]
       end
     end
-    
+
     describe 'with invalid quantity' do
       it 'raises exception' do
-        expect { subject.new('hi') }.to raise_exception
+        expect { subject.new('hi') }.to raise_error(ArgumentError, "Invalid quantity: 'hi'")
       end
     end
-    
+
     describe 'with invalid unit' do
       it 'raises exception' do
-        expect { subject.new(3, :finklebaum) }.to raise_exception
+        expect { subject.new(3, :finklebaum) }.to raise_error(ArgumentError, "Invalid unit: 'finklebaum'")
       end
     end
   end
-  
+
   describe '.parse' do
     describe 'quantity' do
       it 'parses scientific notation' do
         m = subject.parse('4.3e12')
-        m.quantity.should eq 4.3e12
-        m.unit.should eq subject::Unit[:count]
-        
+        expect(m.quantity).to eq 4.3e12
+        expect(m.unit).to eq Measurement::Unit[:count]
+
         m = subject.parse('4.3e12 dozen')
-        m.quantity.should eq 4.3e12
-        m.unit.should eq subject::Unit[:dozen]
-        
+        expect(m.quantity).to eq 4.3e12
+        expect(m.unit).to eq Measurement::Unit[:dozen]
+
         m = subject.parse('4.3e12doz')
-        m.quantity.should eq 4.3e12
-        m.unit.should eq subject::Unit[:dozen]
+        expect(m.quantity).to eq 4.3e12
+        expect(m.unit).to eq Measurement::Unit[:dozen]
       end
-      
+
       it 'parses fractions' do
         m = subject.parse('1/4')
-        m.quantity.should eq 0.25
-        m.unit.should eq subject::Unit[:count]
-        
+        expect(m.quantity).to eq 0.25
+        expect(m.unit).to eq Measurement::Unit[:count]
+
         m = subject.parse('1/4 dozen')
-        m.quantity.should eq 0.25
-        m.unit.should eq subject::Unit[:dozen]
-        
+        expect(m.quantity).to eq 0.25
+        expect(m.unit).to eq Measurement::Unit[:dozen]
+
         m = subject.parse('1/4doz')
-        m.quantity.should eq 0.25
-        m.unit.should eq subject::Unit[:dozen]
+        expect(m.quantity).to eq 0.25
+        expect(m.unit).to eq Measurement::Unit[:dozen]
       end
-      
+
       it 'parses mixed fractions' do
         m = subject.parse('3 2/5')
-        m.quantity.should eq 3.4
-        m.unit.should eq subject::Unit[:count]
-        
+        expect(m.quantity).to eq 3.4
+        expect(m.unit).to eq Measurement::Unit[:count]
+
         m = subject.parse('3 2/5 dozen')
-        m.quantity.should eq 3.4
-        m.unit.should eq subject::Unit[:dozen]
-        
-        m = subject.parse('3 2/5')
-        m.quantity.should eq 3.4
-        m.unit.should eq subject::Unit[:count]
+        expect(m.quantity).to eq 3.4
+        expect(m.unit).to eq Measurement::Unit[:dozen]
       end
-      
+
+      it 'parses fractions with special characters' do
+        m = subject.parse('⅜')
+        expect(m.quantity).to eq 0.375
+        expect(m.unit).to eq Measurement::Unit[:count]
+
+        m = subject.parse('⅜ dozen')
+        expect(m.quantity).to eq 0.375
+        expect(m.unit).to eq Measurement::Unit[:dozen]
+
+        m = subject.parse('⅜doz')
+        expect(m.quantity).to eq 0.375
+        expect(m.unit).to eq Measurement::Unit[:dozen]
+      end
+
+      it 'parses mixed fractions with special characters' do
+        m = subject.parse('3⅜')
+        expect(m.quantity).to eq 3.375
+        expect(m.unit).to eq Measurement::Unit[:count]
+
+        m = subject.parse('3 ⅜')
+        expect(m.quantity).to eq 3.375
+        expect(m.unit).to eq Measurement::Unit[:count]
+
+        m = subject.parse('3⅜ dozen')
+        expect(m.quantity).to eq 3.375
+        expect(m.unit).to eq Measurement::Unit[:dozen]
+
+        m = subject.parse('3 ⅜ dozen')
+        expect(m.quantity).to eq 3.375
+        expect(m.unit).to eq Measurement::Unit[:dozen]
+
+        m = subject.parse('3⅜doz')
+        expect(m.quantity).to eq 3.375
+        expect(m.unit).to eq Measurement::Unit[:dozen]
+      end
+
       it 'parses decimals' do
         m = subject.parse('2.1')
-        m.quantity.should eq 2.1
-        m.unit.should eq subject::Unit[:count]
-        
+        expect(m.quantity).to eq 2.1
+        expect(m.unit).to eq Measurement::Unit[:count]
+
         m = subject.parse('2.1 dozen')
-        m.quantity.should eq 2.1
-        m.unit.should eq subject::Unit[:dozen]
-        
+        expect(m.quantity).to eq 2.1
+        expect(m.unit).to eq Measurement::Unit[:dozen]
+
         m = subject.parse('2.1doz')
-        m.quantity.should eq 2.1
-        m.unit.should eq subject::Unit[:dozen]
+        expect(m.quantity).to eq 2.1
+        expect(m.unit).to eq Measurement::Unit[:dozen]
       end
     end
-    
+
     describe 'unit' do
       it 'converts when defined' do
-        subject.parse('3 dozen').unit.should eq subject::Unit[:dozen]
+        expect(subject.parse('3 dozen').unit).to eq Measurement::Unit[:dozen]
       end
-      
+
       it 'raises exception when undefined' do
-        expect { subject.parse('3 finklebaums') }.to raise_error
+        expect { subject.parse('3 finklebaums') }.to raise_error(ArgumentError, "Invalid unit: 'finklebaums'")
       end
     end
   end
-  
+
   describe '.define' do
     it 'delegates to Unit.define' do
-      subject::Unit.should_receive(:define)
+      expect(Measurement::Unit).to receive(:define)
       subject.define(:something)
     end
   end
-  
+
   describe '#convert_to' do
     let(:measurement) { subject.new(3) }
-    
+
     it 'returns copy of self when target unit matches current unit' do
       result = measurement.convert_to(:count)
-      result.should_not be measurement
-      result.should eq measurement
+      expect(result).to_not be measurement
+      expect(result).to eq measurement
     end
-    
+
     it 'returns target unit if it exists and is convertable' do
       result = measurement.convert_to(:dozen)
-      result.quantity.should eq 0.25
-      result.unit.should eq subject::Unit[:dozen]
+      expect(result.quantity).to eq 0.25
+      expect(result.unit).to eq Measurement::Unit[:dozen]
     end
-    
+
     it 'raises exception if unit exists and is not convertable' do
-      expect { measurement.convert_to(:inches) }.to raise_error
+      expect { measurement.convert_to(:inches) }.to raise_error(ArgumentError, "Invalid conversion: 'count' to 'in.'")
     end
-    
+
     it 'raises exception if unit does not exist' do
-      expect { measurement.convert_to(:finklebaum) }.to raise_error
+      expect { measurement.convert_to(:finklebaum) }.to raise_error(ArgumentError, "Invalid unit: 'finklebaum'")
     end
   end
-  
+
   describe '#convert_to!' do
     let(:measurement) { subject.new(3) }
-    
+
     it 'modifies the object' do
       measurement.convert_to!(:dozen)
-      measurement.quantity.should eq 0.25
-      measurement.unit.should eq subject::Unit[:dozen]
+      expect(measurement.quantity).to eq 0.25
+      expect(measurement.unit).to eq Measurement::Unit[:dozen]
     end
   end
-  
+
   describe '#+' do
     let(:measurement) { subject.new(3) }
-    
+
     it 'adds numeric values' do
       result = measurement + 4
-      result.quantity.should eq 7
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq 7
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'adds units of the same type' do
       other = subject.new(4)
-      other.unit.should eq measurement.unit
-      
+      expect(other.unit).to eq measurement.unit
+
       result = measurement + other
-      result.quantity.should eq 7
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq 7
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'adds units of a convertable type' do
       other = subject.new(2, :dozen)
-      other.unit.should_not eq measurement.unit
-      
+      expect(other.unit).to_not eq measurement.unit
+
       result = measurement + other
-      result.quantity.should eq 27
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq 27
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'raises exception for incompatible units' do
       other = subject.new(4, :inches)
-      other.unit.should_not eq measurement.unit
-      expect { measurement + other }.to raise_error
+      expect(other.unit).to_not eq measurement.unit
+      expect { measurement + other }.to raise_error(ArgumentError, "Invalid conversion: 'in.' to 'count'")
     end
   end
-  
+
   describe '#-' do
     let(:measurement) { subject.new(3) }
-    
+
     it 'subtracts numeric values' do
       result = measurement - 4
-      result.quantity.should eq -1
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq(-1)
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'subtracts units of the same type' do
       other = subject.new(4)
-      other.unit.should eq measurement.unit
-      
+      expect(other.unit).to eq measurement.unit
+
       result = measurement - other
-      result.quantity.should eq -1
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq(-1)
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'subtracts units of a convertable type' do
       other = subject.new(2, :dozen)
-      other.unit.should_not eq measurement.unit
-      
+      expect(other.unit).to_not eq measurement.unit
+
       result = measurement - other
-      result.quantity.should eq -21
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq(-21)
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'raises exception for incompatible units' do
       other = subject.new(4, :inches)
-      other.unit.should_not eq measurement.unit
-      expect { measurement - other }.to raise_error
+      expect(other.unit).to_not eq measurement.unit
+      expect { measurement - other }.to raise_error(ArgumentError, "Invalid conversion: 'in.' to 'count'")
     end
   end
-  
+
   describe '#*' do
     let(:measurement) { subject.new(3) }
-    
+
     it 'multiplies numeric values' do
       result = measurement * 4
-      result.quantity.should eq 12
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq 12
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'multiplies units of the same type' do
       other = subject.new(4)
-      other.unit.should eq measurement.unit
-      
+      expect(other.unit).to eq measurement.unit
+
       result = measurement * other
-      result.quantity.should eq 12
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq 12
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'multiplies units of a convertable type' do
       other = subject.new(2, :dozen)
-      other.unit.should_not eq measurement.unit
-      
+      expect(other.unit).to_not eq measurement.unit
+
       result = measurement * other
-      result.quantity.should eq 72
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq 72
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'raises exception for incompatible units' do
       other = subject.new(4, :inches)
-      other.unit.should_not eq measurement.unit
-      expect { measurement * other }.to raise_error
+      expect(other.unit).to_not eq measurement.unit
+      expect { measurement * other }.to raise_error(ArgumentError, "Invalid conversion: 'in.' to 'count'")
     end
   end
-  
+
   describe '#/' do
     let(:measurement) { subject.new(12) }
-    
+
     it 'divides numeric values' do
       result = measurement / 4
-      result.quantity.should eq 3
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq 3
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'divides units of the same type' do
       other = subject.new(4)
-      other.unit.should eq measurement.unit
-      
+      expect(other.unit).to eq measurement.unit
+
       result = measurement / other
-      result.quantity.should eq 3
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq 3
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'divides units of a convertable type' do
       other = subject.new(1, :dozen)
-      other.unit.should_not eq measurement.unit
-      
+      expect(other.unit).to_not eq measurement.unit
+
       result = measurement / other
-      result.quantity.should eq 1
-      result.unit.should eq measurement.unit
+      expect(result.quantity).to eq 1
+      expect(result.unit).to eq measurement.unit
     end
-    
+
     it 'raises exception for incompatible units' do
       other = subject.new(4, :inches)
-      other.unit.should_not eq measurement.unit
-      expect { measurement / other }.to raise_error
+      expect(other.unit).to_not eq measurement.unit
+      expect { measurement / other }.to raise_error(ArgumentError, "Invalid conversion: 'in.' to 'count'")
     end
   end
-  
+
   describe '#**' do
     let(:measurement) { subject.new(3) }
-    
+
     it 'raises to the power of numeric values' do
-      (measurement ** 3).quantity.should eq 27
+      expect((measurement ** 3).quantity).to eq 27
     end
-    
+
     it 'raises exception for non-numeric values' do
-      expect { measurement ** subject.new(3) }.to raise_error
+      expect { measurement ** subject.new(3) }.to raise_error(ArgumentError, 'Invalid arithmetic: 3 count ** 3 count')
     end
   end
-  
+
   describe '#==' do
     let(:measurement) { subject.new(3) }
-    
+
     it 'returns true for measurements with same quantity and unit' do
-      (measurement == subject.new(3)).should be_true
+      expect(measurement == subject.new(3)).to be true
     end
-    
+
     it 'returns false for measurements with same quantity and different unit' do
-      (measurement == subject.new(3, :dozen)).should be_false
+      expect(measurement == subject.new(3, :dozen)).to be false
     end
-    
+
     it 'returns false for measurements with same unit and different quantity' do
-      (measurement == subject.new(4)).should be_false
+      expect(measurement == subject.new(4)).to be false
     end
-    
+
     it 'returns false for non-measurement objects' do
-      (measurement == 3).should be_false
+      expect(measurement == 3).to be false
     end
   end
-  
+
+  describe '#>' do
+    let(:measurement) { subject.new(3) }
+
+    it 'raises ArgumentError for non-measurement objects' do
+      expect { measurement > 2 }.to raise_error(ArgumentError)
+    end
+
+    it 'returns false for measurements for different unit' do
+      expect { measurement > subject.new(2, :dozen) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns true for measurements with same unit and larger quantity' do
+      expect(measurement > subject.new(2)).to be true
+    end
+
+    it 'returns false for measurements with same unit and smaller quantity' do
+      expect(measurement > subject.new(4)).to be false
+    end
+  end
+
+  describe '#<' do
+    let(:measurement) { subject.new(3) }
+
+    it 'raises ArgumentError for non-measurement objects' do
+      expect { measurement < 4 }.to raise_error(ArgumentError)
+    end
+
+    it 'returns false for measurements for different unit' do
+      expect { measurement < subject.new(4, :dozen) }.to raise_error(ArgumentError)
+    end
+
+    it 'returns true for measurements with same unit and smaller quantity' do
+      expect(measurement < subject.new(4)).to be true
+    end
+
+    it 'returns false for measurements with same unit and larger quantity' do
+      expect(measurement < subject.new(2)).to be false
+    end
+  end
+
   describe '#to_s' do
     it 'returns the quantity and unit' do
-      subject.new(3.5).to_s.should eq '3.5 count'
-      subject.new(2, :dozen).to_s.should eq '2 doz'
+      expect(subject.new(3.5).to_s).to eq '3.5 count'
+      expect(subject.new(2, :dozen).to_s).to eq '2 doz'
     end
   end
-  
+
   describe '#inspect' do
     it 'returns the quantity and unit' do
-      subject.new(3.5).inspect.should eq '3.5 count'
-      subject.new(2, :dozen).inspect.should eq '2 doz'
+      expect(subject.new(3.5).inspect).to eq '3.5 count'
+      expect(subject.new(2, :dozen).inspect).to eq '2 doz'
     end
   end
 end