measured 1.6.0 → 2.0.0.pre1

data/lib/measured/units/length.rb

@@ -1,26 +1,8 @@
-class Measured::Length < Measured::Measurable
-
-  conversion.set_base :m,
-    aliases: [:meter, :metre, :meters, :metres]
-
-  conversion.add :cm,
-    aliases: [:centimeter, :centimetre, :centimeters, :centimetres],
-    value: "0.01 m"
-
-  conversion.add :mm,
-    aliases: [:millimeter, :millimetre, :millimeters, :millimetres],
-    value: "0.001 m"
-
-  conversion.add :in,
-    aliases: [:inch, :inches],
-    value: "0.0254 m"
-
-  conversion.add :ft,
-    aliases: [:foot, :feet],
-    value: "0.3048 m"
-
-  conversion.add :yd,
-    aliases: [:yard, :yards],
-    value: "0.9144 m"
-
+Measured::Length = Measured.build do
+  unit :m, aliases: [:meter, :metre, :meters, :metres]
+  unit :cm, value: "1/100 m", aliases: [:centimeter, :centimetre, :centimeters, :centimetres]
+  unit :mm, value: "1/1000 m", aliases: [:millimeter, :millimetre, :millimeters, :millimetres]
+  unit :in, value: "0.0254 m", aliases: [:inch, :inches]
+  unit :ft, value: "12 in", aliases: [:foot, :feet]
+  unit :yd, value: "3 ft", aliases: [:yard, :yards]
 end

data/lib/measured/units/weight.rb

@@ -1,18 +1,6 @@
-class Measured::Weight < Measured::Measurable
-
-  conversion.set_base :g,
-    aliases: [:gram, :grams]
-
-  conversion.add :kg,
-    aliases: [:kilogram, :kilograms],
-    value: "1000 g"
-
-  conversion.add :lb,
-    aliases: [:lbs, :pound, :pounds],
-    value: [Rational(45359237,1e8), "kg"]
-
-  conversion.add :oz,
-    aliases: [:ounce, :ounces],
-    value: [Rational(1,16), "lb"]
-
+Measured::Weight = Measured.build do
+  unit :g, aliases: [:gram, :grams]
+  unit :kg, value: "1000 g", aliases: [:kilogram, :kilograms]
+  unit :lb, value: "0.45359237 kg", aliases: [:lbs, :pound, :pounds]
+  unit :oz, value: "1/16 lb", aliases: [:ounce, :ounces]
 end

data/lib/measured/version.rb

@@ -1,3 +1,3 @@
 module Measured
-  VERSION = "1.6.0"
+  VERSION = "2.0.0.pre1"
 end

data/measured.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "activesupport", ">= 4.0"
+  spec.add_runtime_dependency "activesupport", ">= 4.2"
 
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.5.1"

data/test/arithmetic_test.rb

@@ -12,9 +12,9 @@ class Measured::ArithmeticTest < ActiveSupport::TestCase
     assert_equal Magic.new(5, :magic_missile), @three + @two
   end
 
-  test "#+ should add a number to the value" do
-    assert_equal Magic.new(5, :magic_missile), @two + 3
-    assert_equal Magic.new(5, :magic_missile), 2 + @three
+  test "#+ shouldn't add with a Integer" do
+    assert_raises(TypeError) { @two + 3 }
+    assert_raises(TypeError) { 2 + @three }
   end
 
   test "#+ should raise if different unit system" do
@@ -42,9 +42,9 @@ class Measured::ArithmeticTest < ActiveSupport::TestCase
     assert_equal Magic.new(1, :magic_missile), @three - @two
   end
 
-  test "#- should subtract a number from the value" do
-    assert_equal Magic.new(-1, :magic_missile), @two - 3
-    assert_equal Magic.new(1, :magic_missile), 2 - @three
+  test "#- shouldn't subtract with a Integer" do
+    assert_raises(TypeError) { @two - 3 }
+    assert_raises(TypeError) { 2 - @three }
   end
 
   test "#- should raise if different unit system" do
@@ -67,67 +67,30 @@ class Measured::ArithmeticTest < ActiveSupport::TestCase
     end
   end
 
-  test "#* should multiply together same units" do
-    assert_equal Magic.new(6, :magic_missile), @two * @three
-    assert_equal Magic.new(6, :magic_missile), @three * @two
-  end
-
-  test "#* should multiply a number to the value" do
-    assert_equal Magic.new(6, :magic_missile), @two * 3
-    assert_equal Magic.new(6, :magic_missile), 2 * @three
-  end
-
-  test "#* should raise if different unit system" do
-    assert_raises TypeError do
-      OtherFakeSystem.new(1, :other_fake_base) * @two
-    end
-
-    assert_raises TypeError do
-      @two * OtherFakeSystem.new(1, :other_fake_base)
-    end
-  end
-
-  test "#* should raise if multiplying something nonsense" do
-    assert_raises TypeError do
-      @two * "thing"
-    end
-
-    assert_raises TypeError do
-      "thing" * @two
-    end
-  end
-
-  test "#/ should divide together same units" do
-    assert_equal Magic.new("0.5", :magic_missile), @two / @four
-    assert_equal Magic.new(2, :magic_missile), @four / @two
+  test "#-@ returns the negative version" do
+    assert_equal Magic.new(-2, :magic_missile), -@two
   end
 
-  test "#/ should divide a number to the value" do
-    assert_equal Magic.new("0.5", :magic_missile), @two / 4
-    assert_equal Magic.new(2, :magic_missile), 2 / @four
+  test "#scale should multiply the value by a given scalar" do
+    assert_equal Magic.new(-2, :magic_missile), @two.scale(-1)
+    assert_equal Magic.new(5, :magic_missile), @two.scale(2.5)
   end
 
-  test "#/ should raise if different unit system" do
-    assert_raises TypeError do
-      OtherFakeSystem.new(1, :other_fake_base) / @two
-    end
+  test "arithmetic operations favours unit of left" do
+    left = Magic.new(1, :arcane)
+    right = Magic.new(1, :magic_missile)
 
-    assert_raises TypeError do
-      @two / OtherFakeSystem.new(1, :other_fake_base)
-    end
+    assert_equal "arcane", (left + right).unit
+    assert_equal "arcane", (left - right).unit
   end
 
-  test "#/ should raise if dividing something nonsense" do
-    assert_raises TypeError do
-      @two / "thing"
-    end
-
-    assert_raises NoMethodError do
-      "thing" / @two
-    end
+  test "#coerce should return other as-is when same class" do
+    assert_equal [@two, @three], @three.coerce(@two)
   end
 
-  test "#-@ returns the negative version" do
-    assert_equal Magic.new(-2, :magic_missile), -@two
+  test "#coerce should raise TypeError when other cannot be coerced" do
+    assert_raises(TypeError) { @two.coerce(2) }
+    assert_raises(TypeError) { @three.coerce(5.2) }
+    assert_raises(TypeError) { @four.coerce(Object.new) }
   end
 end

data/test/case_insensitive_unit_system_test.rb

@@ -0,0 +1,98 @@
+require "test_helper"
+
+class Measured::CaseInsensitiveUnitSystemTest < ActiveSupport::TestCase
+  setup do
+    @conversion = Measured::CaseInsensitiveUnitSystem.new([
+      Measured::CaseInsensitiveUnit.new(:m),
+      Measured::CaseInsensitiveUnit.new(:in, aliases: [:inch], value: "0.0254 m"),
+      Measured::CaseInsensitiveUnit.new(:ft, aliases: [:feet, :foot], value: "0.3048 m"),
+    ])
+  end
+
+  test "#unit_names_with_aliases lists all allowed unit names" do
+    assert_equal ["feet", "foot", "ft", "in", "inch", "m"], @conversion.unit_names_with_aliases
+  end
+
+  test "#unit_names lists all base unit names without aliases" do
+    assert_equal ["ft", "in", "m"], @conversion.unit_names
+  end
+
+  test "#unit? checks if the unit is part of the units but not aliases" do
+    assert @conversion.unit?(:in)
+    assert @conversion.unit?("m")
+    assert @conversion.unit?("M")
+    refute @conversion.unit?("inch")
+    refute @conversion.unit?(:yard)
+  end
+
+  test "#unit? with blank and nil arguments" do
+    refute @conversion.unit?("")
+    refute @conversion.unit?(nil)
+  end
+
+  test "#unit_or_alias? checks if the unit is part of the units or aliases" do
+    assert @conversion.unit_or_alias?(:inch)
+    assert @conversion.unit_or_alias?("m")
+    assert @conversion.unit_or_alias?(:IN)
+    assert @conversion.unit_or_alias?("in")
+    refute @conversion.unit_or_alias?(:yard)
+  end
+
+  test "#unit_or_alias? with blank and nil arguments" do
+    refute @conversion.unit_or_alias?("")
+    refute @conversion.unit_or_alias?(nil)
+  end
+
+  test "#to_unit_name converts a unit name to its base unit" do
+    assert_equal "fireball", Magic.unit_system.to_unit_name("fire")
+  end
+
+  test "#to_unit_name does not care about string or symbol" do
+    assert_equal "fireball", Magic.unit_system.to_unit_name(:fire)
+  end
+
+  test "#to_unit_name passes through if already base unit name" do
+    assert_equal "fireball", Magic.unit_system.to_unit_name("fireball")
+  end
+
+  test "#to_unit_name returns nil if not found" do
+    assert_nil Magic.unit_system.to_unit_name("thunder")
+  end
+
+  test "#to_unit_name! converts a unit name to its base unit" do
+    assert_equal "fireball", Magic.unit_system.to_unit_name!("fire")
+  end
+
+  test "#to_unit_name! does not care about string or symbol" do
+    assert_equal "fireball", Magic.unit_system.to_unit_name!(:fire)
+  end
+
+  test "#to_unit_name! passes through if already base unit name" do
+    assert_equal "fireball", Magic.unit_system.to_unit_name!("fireball")
+  end
+
+  test "#to_unit_name! raises if not found" do
+    assert_raises_with_message(Measured::UnitError, "Unit 'thunder' does not exist") do
+      Magic.unit_system.to_unit_name!("thunder")
+    end
+  end
+
+  test "#convert raises if either unit is not found" do
+    assert_raises Measured::UnitError do
+      Magic.unit_system.convert(1, from: "fire", to: "doesnt_exist")
+    end
+
+    assert_raises Measured::UnitError do
+      Magic.unit_system.convert(1, from: "doesnt_exist", to: "fire")
+    end
+  end
+
+  test "#convert converts between two known units" do
+    assert_equal BigDecimal("3"), @conversion.convert(BigDecimal("36"), from: "in", to: "ft")
+    assert_equal BigDecimal("18"), @conversion.convert(BigDecimal("1.5"), from: "ft", to: "in")
+  end
+
+  test "#convert handles the same unit" do
+    assert_equal BigDecimal("2"), @conversion.convert(BigDecimal("2"), from: "in", to: "in")
+  end
+end

data/test/case_insensitive_unit_test.rb

@@ -0,0 +1,79 @@
+require "test_helper"
+
+class Measured::CaseInsensitiveUnitTest < ActiveSupport::TestCase
+  setup do
+    @unit = Measured::CaseInsensitiveUnit.new(:Pie, value: "10 Cake")
+    @unit_with_aliases = Measured::CaseInsensitiveUnit.new(:Pie, aliases: ["Cake", "Tart"])
+  end
+
+  test "#initialize converts the name to a downcased string" do
+    assert_equal "pie", @unit.name
+  end
+
+  test "#initialize converts aliases to strings and makes a list of sorted, downcased names" do
+    assert_equal %w(cake pie sweets), Measured::CaseInsensitiveUnit.new(:pie, aliases: ["Cake", :Sweets]).names
+  end
+
+  test "#initialize parses out the unit and the number part" do
+    assert_equal BigDecimal(10), @unit.conversion_amount
+    assert_equal "Cake", @unit.conversion_unit
+
+    unit = Measured::CaseInsensitiveUnit.new(:pie, value: "5.5 sweets")
+    assert_equal BigDecimal("5.5"), unit.conversion_amount
+    assert_equal "sweets", unit.conversion_unit
+  end
+
+  test "#initialize raises if the format of the value is incorrect" do
+    assert_raises Measured::UnitError do
+      Measured::CaseInsensitiveUnit.new(:pie, value: "hello")
+    end
+
+    assert_raises Measured::UnitError do
+      Measured::CaseInsensitiveUnit.new(:pie, value: "pie is delicious")
+    end
+
+    assert_raises Measured::UnitError do
+      Measured::CaseInsensitiveUnit.new(:pie, value: "123456")
+    end
+  end
+
+  test "#to_s returns an expected string" do
+    assert_equal "pie", Measured::CaseInsensitiveUnit.new(:pie).to_s
+    assert_equal "pie (1/2 sweet)", Measured::CaseInsensitiveUnit.new(:pie, aliases: ["cake"], value: [Rational(1,2), "sweet"]).to_s
+  end
+
+  test "#inspect returns an expected string" do
+    assert_equal "#<Measured::Unit: pie (pie) >", Measured::CaseInsensitiveUnit.new(:pie).inspect
+    assert_equal "#<Measured::Unit: pie (cake, pie) 1/2 sweet>", Measured::CaseInsensitiveUnit.new(:pie, aliases: ["cake"], value: [Rational(1,2), "sweet"]).inspect
+  end
+
+  test "includes Comparable mixin" do
+    assert Measured::Unit.ancestors.include?(Comparable)
+  end
+
+  test "#<=> compares non-Unit classes against name" do
+    assert_equal 1, @unit <=> "pap"
+    assert_equal -1, @unit <=> "pop"
+  end
+
+  test "#<=> is 0 for Unit instances that should be equivalent" do
+    assert_equal 0, @unit <=> Measured::CaseInsensitiveUnit.new(:Pie, value: "10 cake")
+    assert_equal 0, @unit <=> Measured::CaseInsensitiveUnit.new("Pie", value: "10 cake")
+    assert_equal 0, @unit <=> Measured::CaseInsensitiveUnit.new("Pie", value: [10, :cake])
+  end
+
+  test "#<=> is 1 for " do
+    assert_equal 1, @unit <=> Measured::CaseInsensitiveUnit.new(:pies, value: "10 cake")
+    assert_equal 1, @unit <=> Measured::CaseInsensitiveUnit.new("pie", aliases: ["pies"], value: "10 cake")
+    assert_equal 1, @unit <=> Measured::CaseInsensitiveUnit.new(:pie, value: [11, :cake])
+  end
+
+  test "#inverse_conversion_amount returns 1/amount for BigDecimal" do
+    assert_equal BigDecimal(1) / 10, @unit.inverse_conversion_amount
+  end
+
+  test "#inverse_conversion_amount swaps the numerator and denominator for Rational" do
+    unit = Measured::CaseInsensitiveUnit.new(:pie, value: [Rational(3, 7), "cake"])
+    assert_equal Rational(7, 3), unit.inverse_conversion_amount
+  end
+end

data/test/conversion_table_test.rb

@@ -1,19 +1,98 @@
 require "test_helper"
 
 class Measured::ConversionTableTest < ActiveSupport::TestCase
-  setup do
-    @unit = Measured::Unit.new(:test)
+  test ".build should return a hash for the simple case" do
+    expected = {
+      "test" => {"test" => BigDecimal("1")}
+    }
+
+    assert_equal expected, Measured::ConversionTable.build([Measured::Unit.new(:test)])
   end
 
-  test "#initialize accepts a list of units and a base unit" do
-    Measured::ConversionTable.new([@unit])
+  test ".build returns expected nested hashes with BigDecimal conversion factors in a tiny data set" do
+    conversion_table = Measured::ConversionTable.build([
+      Measured::Unit.new(:m),
+      Measured::Unit.new(:cm, value: "0.01 m"),
+    ])
+
+    expected = {
+      "m" => {
+        "m" => BigDecimal("1"),
+        "cm" => BigDecimal("100"),
+      },
+      "cm" => {
+        "m" => BigDecimal("0.01"),
+        "cm" => BigDecimal("1"),
+      }
+    }
+
+    assert_equal expected, conversion_table
   end
 
-  test "#to_h should return a hash for the simple case" do
+  test ".build returns expected nested hashes with BigDecimal conversion factors" do
+    conversion_table = Measured::ConversionTable.build([
+      Measured::Unit.new(:m),
+      Measured::Unit.new(:cm, value: "0.01 m"),
+      Measured::Unit.new(:mm, value: "0.001 m"),
+    ])
+
     expected = {
-      "test" => {"test" => BigDecimal("1")}
+      "m" => {
+        "m" => BigDecimal("1"),
+        "cm" => BigDecimal("100"),
+        "mm" => BigDecimal("1000"),
+      },
+      "cm" => {
+        "m" => BigDecimal("0.01"),
+        "cm" => BigDecimal("1"),
+        "mm" => BigDecimal("10"),
+      },
+      "mm" => {
+        "m" => BigDecimal("0.001"),
+        "cm" => BigDecimal("0.1"),
+        "mm" => BigDecimal("1"),
+      }
+    }
+
+    assert_equal expected, conversion_table
+  end
+
+  test ".build returns expected nested hashes with BigDecimal conversion factors in an indrect path" do
+    conversion_table = Measured::ConversionTable.build([
+      Measured::Unit.new(:mm),
+      Measured::Unit.new(:cm, value: "10 mm"),
+      Measured::Unit.new(:dm, value: "10 cm"),
+      Measured::Unit.new(:m, value: "10 dm"),
+    ])
+
+    expected = {
+      "m" => {
+        "m" => BigDecimal("1"),
+        "dm" => BigDecimal("10"),
+        "cm" => BigDecimal("100"),
+        "mm" => BigDecimal("1000"),
+      },
+      "cm" => {
+        "m" => BigDecimal("0.01"),
+        "dm" => BigDecimal("0.1"),
+        "cm" => BigDecimal("1"),
+        "mm" => BigDecimal("10"),
+      },
+      "dm" => {
+        "m" => BigDecimal("0.1"),
+        "cm" => BigDecimal("10"),
+        "dm" => BigDecimal("1"),
+        "mm" => BigDecimal("100"),
+      },
+      "mm" => {
+        "m" => BigDecimal("0.001"),
+        "dm" => BigDecimal("0.01"),
+        "cm" => BigDecimal("0.1"),
+        "mm" => BigDecimal("1"),
+      }
     }
 
-    assert_equal expected, Measured::ConversionTable.new([@unit]).to_h
+    assert_equal expected, conversion_table
   end
+
 end

data/test/measurable_test.rb

@@ -50,14 +50,14 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     exception = assert_raises(Measured::UnitError) do
       Magic.new(nil, :fire)
     end
-    assert_equal "Unit value cannot be nil", exception.message
+    assert_equal "Unit value cannot be blank", exception.message
   end
 
   test "#initialize raises an expected error when initializing with nil unit" do
     exception = assert_raises(Measured::UnitError) do
       Magic.new(1, nil)
     end
-    assert_equal "Unit cannot be blank", exception.message
+    assert_equal "Unit '' does not exist", exception.message
   end
 
   test "#initialize raises an expected error when initializing with empty string value" do
@@ -71,7 +71,7 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     exception = assert_raises(Measured::UnitError) do
       Magic.new(1, "")
     end
-    assert_equal "Unit cannot be blank", exception.message
+    assert_equal "Unit '' does not exist", exception.message
   end
 
   test "#unit allows you to read the unit string" do
@@ -83,34 +83,36 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
   end
 
   test ".conversion is set and cached" do
-    conversion = Magic.conversion
+    conversion = CaseSensitiveMagic.unit_system
 
-    assert_instance_of Measured::Conversion, conversion
-    assert_equal conversion, Magic.conversion
+    assert_instance_of Measured::UnitSystem, conversion
+    assert_equal conversion.__id__, CaseSensitiveMagic.unit_system.__id__
   end
 
-  test ".units returns just the base units" do
-    assert_equal ["arcane", "fireball", "ice", "magic_missile", "ultima"], Magic.units
+  test ".unit_names returns just the base unit names" do
+    assert_equal %w(arcane fireball ice magic_missile ultima), Magic.unit_names
   end
 
-  test ".units_with_aliases returns all units" do
-    assert_equal ["arcane", "fire", "fireball", "fireballs", "ice", "magic_missile", "magic_missiles", "ultima"], Magic.units_with_aliases
+  test ".unit_names_with_aliases returns all units" do
+    assert_equal(
+      %w(arcane fire fireball fireballs ice magic_missile magic_missiles ultima),
+      Magic.unit_names_with_aliases
+    )
   end
 
-  test ".valid_unit? looks at the list of units and aliases" do
-    assert Magic.valid_unit?("fire")
-    assert Magic.valid_unit?("fireball")
-    assert Magic.valid_unit?(:ice)
-    refute Magic.valid_unit?("junk")
+  test ".unit_or_alias? looks at the list of units and aliases" do
+    assert Magic.unit_or_alias?("fire")
+    assert Magic.unit_or_alias?("fireball")
+    assert Magic.unit_or_alias?(:ice)
+    refute Magic.unit_or_alias?("junk")
   end
 
   test ".name looks at the class name" do
     module Example
-      class VeryComplexThing < Measured::Measurable ; end
+      VeryComplexThing = Measured.build { unit :foo }
     end
 
     assert_equal "magic", Magic.name
-    assert_equal "measurable", Measured::Measurable.name
     assert_equal "very complex thing", Example::VeryComplexThing.name
   end
 
@@ -136,63 +138,51 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     assert_equal converted.object_id, @magic.object_id
   end
 
-  test "#convert_to! replaces the existing object with a new version in the new unit" do
-    converted = @magic.convert_to!(:arcane)
-
-    assert_equal converted, @magic
-    assert_equal BigDecimal(1), @magic.value
-    assert_equal "arcane", @magic.unit
-    assert_equal BigDecimal(1), converted.value
-    assert_equal "arcane", converted.unit
-  end
-
   test "#to_s outputs the number and the unit" do
     assert_equal "10 fireball", Magic.new(10, :fire).to_s
     assert_equal "1.234 magic_missile", Magic.new("1.234", :magic_missile).to_s
   end
 
   test "#inspect shows the number and the unit" do
-    assert_equal "#<Magic: 10.0 fireball>", Magic.new(10, :fire).inspect
+    assert_equal "#<Magic: 10 fireball>", Magic.new(10, :fire).inspect
     assert_equal "#<Magic: 1.234 magic_missile>", Magic.new(1.234, :magic_missile).inspect
   end
 
-  test "#zero? delegates to the value" do
-    assert Magic.new(0, :fire).zero?
-    refute Magic.new(2, :fire).zero?
+  test "#zero? always returns false" do
+    refute_predicate Magic.new(0, :fire), :zero?
+    refute_predicate Magic.new(0.0, :fire), :zero?
+    refute_predicate Magic.new("0.0", :fire), :zero?
   end
 
   test "#<=> compares regardless of the unit" do
-    assert_equal -1, @magic <=> Magic.new(10, :fire)
+    assert_equal -1, @magic <=> Magic.new(20, :fire)
     assert_equal 1, @magic <=> Magic.new(9, :magic_missile)
-    assert_equal 0, @magic <=> Magic.new(10, :magic_missile)
+    assert_equal 0, @magic <=> Magic.new(Rational(30, 2), :fire)
     assert_equal -1, @magic <=> Magic.new(11, :magic_missile)
   end
 
-  test "#<=> compares against zero" do
-    assert_equal 1, @magic <=> 0
-    assert_equal 1, @magic <=> BigDecimal.new(0)
-    assert_equal 1, @magic <=> 0.00
-    assert_equal -1, Magic.new(-1, :magic_missile) <=> 0
+  test "#<=> doesn't compare against zero" do
+    assert_nil @magic <=> 0
+    assert_nil @magic <=> BigDecimal.new(0)
+    assert_nil @magic <=> 0.00
   end
 
   test "#== should be the same if the classes, unit, and amount match" do
-    assert @magic == @magic
-    assert Magic.new(10, :magic_missile) == Magic.new("10", "magic_missile")
-    assert Magic.new(1, :arcane) == Magic.new(10, :magic_missile)
-    refute Magic.new(1, :arcane) == Magic.new(10.1, :magic_missile)
+    assert_equal @magic, @magic
+    assert_equal Magic.new(10, :magic_missile), Magic.new("10", "magic_missile")
+    assert_equal Magic.new(1, :arcane), Magic.new(10, :magic_missile)
+    refute_equal Magic.new(1, :arcane), Magic.new(10.1, :magic_missile)
   end
 
   test "#== should be the same if the classes and amount match but the unit does not so they convert" do
-    assert Magic.new(2, :magic_missile) == Magic.new("1", "ice")
+    assert_equal Magic.new(2, :magic_missile), Magic.new("1", "ice")
   end
 
-  test "#== compares against zero" do
-    assert Magic.new(0, :fire) == 0
-    assert Magic.new(0, :magic_missile) == 0
-    assert Magic.new(0, :fire) == BigDecimal.new(0)
-    assert Magic.new(0, :fire) == 0.00
-    refute @magic == 0
-    refute @magic == BigDecimal.new(0)
+  test "#== doesn't compare against zero" do
+    arcane_zero = Magic.new(0, :arcane)
+    refute_equal arcane_zero, 0
+    refute_equal arcane_zero, BigDecimal.new(0)
+    refute_equal arcane_zero, 0.0
   end
 
   test "#> and #< should compare measurements" do
@@ -205,13 +195,13 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     refute Magic.new(10, :magic_missile) > Magic.new(100, :ice)
   end
 
-  test "#> and #< should compare against zero" do
-    assert @magic > 0
-    assert @magic > BigDecimal.new(0)
-    assert @magic > 0.00
-    assert Magic.new(-1, :arcane) < 0
-    refute @magic < 0
-    refute Magic.new(-1, :arcane) > 0
+  test "#> and #< should not compare against zero" do
+    assert_raises(ArgumentError) { @magic > 0 }
+    assert_raises(ArgumentError) { @magic > BigDecimal.new(0) }
+    assert_raises(ArgumentError) { @magic > 0.00 }
+    assert_raises(ArgumentError) { @magic < 0 }
+    assert_raises(ArgumentError) { @magic < BigDecimal.new(0) }
+    assert_raises(ArgumentError) { @magic < 0.00 }
   end
 
   test "#eql? should be the same if the classes and amount match, and unit is converted" do