measured 1.6.0 → 2.0.0.pre1

data/test/case_sensitive_measurable_test.rb

@@ -1,227 +0,0 @@
-require "test_helper"
-
-class Measured::CaseSensitiveMeasurableTest < ActiveSupport::TestCase
-
-  setup do
-    @magic = CaseSensitiveMagic.new(10, :magic_missile)
-  end
-
-  test "#initialize requires two params, the amount and the unit" do
-    assert_nothing_raised do
-      CaseSensitiveMagic.new(1, "fireball")
-    end
-
-    assert_raises ArgumentError do
-      CaseSensitiveMagic.new(1)
-    end
-  end
-
-  test "#initialize converts unit to string from symbol" do
-    magic = CaseSensitiveMagic.new(1, :arcane)
-    assert_equal "arcane", magic.unit
-  end
-
-  test "#initialize raises if it is an unknown unit" do
-    assert_raises Measured::UnitError do
-      CaseSensitiveMagic.new(1, "slash")
-    end
-  end
-
-  test "#initialize converts numbers and strings into BigDecimal" do
-    assert_equal BigDecimal(1), CaseSensitiveMagic.new(1, :arcane).value
-    assert_equal BigDecimal("2.3"), CaseSensitiveMagic.new("2.3", :arcane).value
-    assert_equal BigDecimal("5"), CaseSensitiveMagic.new("5", :arcane).value
-  end
-
-  test "#initialize converts floats to strings and then to BigDecimal so it does not raise" do
-    assert_equal BigDecimal("1.2345"), CaseSensitiveMagic.new(1.2345, :fire).value
-  end
-
-  test "#initialize converts numbers and strings BigDecimal and does not round large numbers" do
-    assert_equal BigDecimal(9.1234572342342, 14), CaseSensitiveMagic.new(9.1234572342342, :fire).value
-    assert_equal BigDecimal("9.1234572342342"), CaseSensitiveMagic.new(9.1234572342342, :fire).value
-  end
-
-  test "#initialize converts to the base unit name" do
-    assert_equal "fireball", CaseSensitiveMagic.new(1, :fire).unit
-  end
-
-  test "#initialize raises an expected error when initializing with nil value" do
-    exception = assert_raises(Measured::UnitError) do
-      CaseSensitiveMagic.new(nil, :fire)
-    end
-    assert_equal "Unit value cannot be nil", exception.message
-  end
-
-  test "#initialize raises an expected error when initializing with nil unit" do
-    exception = assert_raises(Measured::UnitError) do
-      CaseSensitiveMagic.new(1, nil)
-    end
-    assert_equal "Unit cannot be blank", exception.message
-  end
-
-  test "#initialize raises an expected error when initializing with empty string value" do
-    exception = assert_raises(Measured::UnitError) do
-      CaseSensitiveMagic.new("", :fire)
-    end
-    assert_equal "Unit value cannot be blank", exception.message
-  end
-
-  test "#initialize raises an expected error when initializing with empty string unit" do
-    exception = assert_raises(Measured::UnitError) do
-      CaseSensitiveMagic.new(1, "")
-    end
-    assert_equal "Unit cannot be blank", exception.message
-  end
-
-  test "#unit allows you to read the unit string" do
-    assert_equal "magic_missile", @magic.unit
-  end
-
-  test "#value allows you to read the numeric value" do
-    assert_equal BigDecimal(10), @magic.value
-  end
-
-  test ".conversion is set and cached" do
-    conversion = CaseSensitiveMagic.conversion
-
-    assert_instance_of Measured::Conversion, conversion
-    assert_equal conversion, CaseSensitiveMagic.conversion
-  end
-
-  test ".conversion is set to case sensitive" do
-    conversion = CaseSensitiveMagic.conversion
-
-    assert_instance_of Measured::Conversion, conversion
-    assert_equal conversion, CaseSensitiveMagic.conversion
-    assert_equal true, conversion.case_sensitive
-  end
-
-  test ".units returns just the base units" do
-    assert_equal ["arcane", "fireball", "ice", "magic_missile", "ultima"], CaseSensitiveMagic.units
-  end
-
-  test ".units_with_aliases returns all units" do
-    assert_equal ["arcane", "fire", "fireball", "fireballs", "ice", "magic_missile", "magic_missiles", "ultima"], CaseSensitiveMagic.units_with_aliases
-  end
-
-  test ".valid_unit? looks at the list of units and aliases" do
-    assert CaseSensitiveMagic.valid_unit?("fire")
-    assert CaseSensitiveMagic.valid_unit?("fireball")
-    assert CaseSensitiveMagic.valid_unit?(:ice)
-    refute CaseSensitiveMagic.valid_unit?("junk")
-  end
-
-  test ".name looks at the class name" do
-    module Example
-      class VeryComplexThing < Measured::Measurable ; end
-    end
-
-    assert_equal "case sensitive magic", CaseSensitiveMagic.name
-    assert_equal "measurable", Measured::Measurable.name
-    assert_equal "very complex thing", Example::VeryComplexThing.name
-  end
-
-  test "#convert_to raises on an invalid unit" do
-    assert_raises Measured::UnitError do
-      @magic.convert_to(:punch)
-    end
-  end
-
-  test "#convert_to returns a new object of the same type in the new unit" do
-    converted = @magic.convert_to(:arcane)
-
-    assert_equal converted, @magic
-    refute_equal converted.object_id, @magic.object_id
-    assert_equal BigDecimal(10), @magic.value
-    assert_equal "magic_missile", @magic.unit
-    assert_equal BigDecimal(1), converted.value
-    assert_equal "arcane", converted.unit
-  end
-
-  test "#convert_to from and to the same unit returns the same object" do
-    converted = @magic.convert_to(@magic.unit)
-    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", CaseSensitiveMagic.new(10, :fire).to_s
-    assert_equal "1.234 magic_missile", CaseSensitiveMagic.new("1.234", :magic_missile).to_s
-  end
-
-  test "#inspect shows the number and the unit" do
-    assert_equal "#<CaseSensitiveMagic: 10.0 fireball>", CaseSensitiveMagic.new(10, :fire).inspect
-    assert_equal "#<CaseSensitiveMagic: 1.234 magic_missile>", CaseSensitiveMagic.new(1.234, :magic_missile).inspect
-  end
-
-  test "#<=> compares regardless of the unit" do
-    assert_equal -1, @magic <=> CaseSensitiveMagic.new(10, :fire)
-    assert_equal 1, @magic <=> CaseSensitiveMagic.new(9, :magic_missile)
-    assert_equal 0, @magic <=> CaseSensitiveMagic.new(10, :magic_missile)
-    assert_equal -1, @magic <=> CaseSensitiveMagic.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, CaseSensitiveMagic.new(-1, :magic_missile) <=> 0
-  end
-
-  test "#== should be the same if the classes, unit, and amount match" do
-    assert @magic == @magic
-    assert CaseSensitiveMagic.new(10, :magic_missile) == CaseSensitiveMagic.new("10", "magic_missile")
-    assert CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10, :magic_missile)
-    refute CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.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 CaseSensitiveMagic.new(2, :magic_missile) == CaseSensitiveMagic.new("1", "ice")
-  end
-
-  test "#== compares against zero" do
-    assert CaseSensitiveMagic.new(0, :fire) == 0
-    assert CaseSensitiveMagic.new(0, :magic_missile) == 0
-    assert CaseSensitiveMagic.new(0, :fire) == BigDecimal.new(0)
-    assert CaseSensitiveMagic.new(0, :fire) == 0.00
-    refute @magic == 0
-    refute @magic == BigDecimal.new(0)
-  end
-
-  test "#> and #< should compare measurements" do
-    assert CaseSensitiveMagic.new(10, :magic_missile) < CaseSensitiveMagic.new(20, :magic_missile)
-    refute CaseSensitiveMagic.new(10, :magic_missile) > CaseSensitiveMagic.new(20, :magic_missile)
-  end
-
-  test "#> and #< should compare measurements of different units" do
-    assert CaseSensitiveMagic.new(10, :magic_missile) < CaseSensitiveMagic.new(100, :ice)
-    refute CaseSensitiveMagic.new(10, :magic_missile) > CaseSensitiveMagic.new(100, :ice)
-  end
-
-  test "#> and #< should compare against zero" do
-    assert @magic > 0
-    assert @magic > BigDecimal.new(0)
-    assert @magic > 0.00
-    assert CaseSensitiveMagic.new(-1, :arcane) < 0
-    refute @magic < 0
-    refute CaseSensitiveMagic.new(-1, :arcane) > 0
-  end
-
-  test "#eql? should be the same if the classes and amount match, and unit is converted" do
-    assert @magic == @magic
-    assert CaseSensitiveMagic.new(10, :magic_missile) == CaseSensitiveMagic.new("10", "magic_missile")
-    assert CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10, :magic_missile)
-    refute CaseSensitiveMagic.new(1, :arcane) == CaseSensitiveMagic.new(10.1, :magic_missile)
-  end
-
-end

data/test/conversion_test.rb

@@ -1,243 +0,0 @@
-require "test_helper"
-
-class Measured::ConversionTest < ActiveSupport::TestCase
-  setup do
-    @conversion = Measured::Conversion.new
-  end
-
-  test "#base sets the base unit" do
-    @conversion.set_base :m, aliases: [:metre]
-    assert_equal ["m", "metre"], @conversion.base_unit.names
-  end
-
-  test "#base doesn't allow a second base to be added" do
-    @conversion.set_base :m, aliases: [:metre]
-
-    assert_raises Measured::UnitError do
-      @conversion.set_base :in
-    end
-  end
-
-  test "#add adds a new unit" do
-    @conversion.set_base :m
-    @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
-
-    assert_equal 2, @conversion.units.count
-  end
-
-  test "#add cannot add duplicate unit names" do
-    @conversion.set_base :m
-    @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
-
-    assert_raises Measured::UnitError do
-      @conversion.add :in, aliases: [:thing], value: "123 m"
-    end
-
-    assert_raises Measured::UnitError do
-      @conversion.add :inch, value: "123 m"
-    end
-  end
-
-  test "#add does not allow you to add a unit before the base" do
-    assert_raises Measured::UnitError do
-      @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
-    end
-  end
-
-  test "#unit_names_with_aliases lists all allowed unit names" do
-    @conversion.set_base :m
-    @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
-    @conversion.add :ft, aliases: [:feet, :foot], value: "0.3048 meter"
-
-    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
-    @conversion.set_base :m
-    @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
-    @conversion.add :ft, aliases: [:feet, :foot], value: "0.3048 meter"
-
-    assert_equal ["ft", "in", "m"], @conversion.unit_names
-  end
-
-  test "#unit? checks if the unit is part of the units and aliases" do
-    @conversion.set_base :m
-    @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
-
-    assert @conversion.unit?(:inch)
-    assert @conversion.unit?("m")
-    assert @conversion.unit?("M")
-    refute @conversion.unit?("in")
-    refute @conversion.unit?(:yard)
-  end
-
-  test "#unit? takes into account case_sensitive flag" do
-    conversion = Measured::Conversion.new(case_sensitive: true)
-    conversion.set_base :m
-    conversion.add :inch, aliases: [:in], value: "0.0254 meter"
-
-    assert conversion.unit?(:inch)
-    assert conversion.unit?("m")
-    refute conversion.unit?("M")
-    refute conversion.unit?("in")
-  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 but not aliases" do
-    @conversion.set_base :m
-    @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
-
-    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? takes into account case_sensitive flag" do
-    conversion = Measured::Conversion.new(case_sensitive: true)
-    conversion.set_base :m
-    conversion.add :inch, aliases: [:in], value: "0.0254 meter"
-
-    assert conversion.unit_or_alias?(:inch)
-    assert conversion.unit_or_alias?("m")
-    refute conversion.unit_or_alias?(:M)
-    refute conversion.unit_or_alias?("IN")
-  end
-
-  test "#unit_or_alias? with blank and nil arguments" do
-    @conversion.set_base :m
-    @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
-
-    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.conversion.to_unit_name("fire")
-  end
-
-  test "#to_unit_name does not care about string or symbol" do
-    assert_equal "fireball", Magic.conversion.to_unit_name(:fire)
-  end
-
-  test "#to_unit_name passes through if already base unit name" do
-    assert_equal "fireball", Magic.conversion.to_unit_name("fireball")
-  end
-
-  test "#to_unit_name raises if not found" do
-    assert_raises Measured::UnitError do
-      Magic.conversion.to_unit_name("thunder")
-    end
-  end
-
-  test "#convert raises if either unit is not found" do
-    assert_raises Measured::UnitError do
-      Magic.conversion.convert(1, from: "fire", to: "doesnt_exist")
-    end
-
-    assert_raises Measured::UnitError do
-      Magic.conversion.convert(1, from: "doesnt_exist", to: "fire")
-    end
-  end
-
-  test "#convert converts betwen two known units" do
-    @conversion.set_base :m
-    @conversion.add :cm, value: "0.01 m"
-
-    assert_equal BigDecimal("10"), @conversion.convert(BigDecimal("1000"), from: "cm", to: "m")
-    assert_equal BigDecimal("250"), @conversion.convert(BigDecimal("2.5"), from: "m", to: "cm")
-  end
-
-  test "#convert handles the same unit" do
-    @conversion.set_base :m
-    @conversion.add :cm, value: "0.01 m"
-
-    assert_equal BigDecimal("2"), @conversion.convert(BigDecimal("2"), from: "cm", to: "cm")
-  end
-
-  test "#conversion_table returns expected nested hashes with BigDecimal conversion factors in a tiny data set" do
-    @conversion.set_base :m
-    @conversion.add :cm, value: "0.01 m"
-
-    expected = {
-      "m"  => {
-        "m"  => BigDecimal("1"),
-        "cm" => BigDecimal("100")
-      },
-      "cm" => {
-        "cm" => BigDecimal("1"),
-        "m"  => BigDecimal("0.01")
-      }
-    }
-
-    assert_equal expected, @conversion.conversion_table
-  end
-
-  test "#conversion_table returns expected nested hashes with BigDecimal conversion factors" do
-    @conversion.set_base :m
-    @conversion.add :cm, value: "0.01 m"
-    @conversion.add :mm, value: "0.001 m"
-
-    expected = {
-      "m"  => {
-        "m"  => BigDecimal("1"),
-        "cm" => BigDecimal("100"),
-        "mm" => BigDecimal("1000")
-      },
-      "cm" => {
-        "cm" => BigDecimal("1"),
-        "m"  => BigDecimal("0.01"),
-        "mm" => BigDecimal("10")
-      },
-      "mm" => {
-        "mm" => BigDecimal("1"),
-        "m"  => BigDecimal("0.001"),
-        "cm" => BigDecimal("0.1")
-      }
-    }
-
-    assert_equal expected, @conversion.conversion_table
-  end
-
-  test "#conversion_table returns expected nested hashes with BigDecimal conversion factors in an indrect path" do
-    @conversion.set_base :mm
-    @conversion.add :cm, value: "10 mm"
-    @conversion.add :dm, value: "10 cm"
-    @conversion.add :m, value: "10 dm"
-
-    expected = {
-      "m"  => {
-        "m"  => BigDecimal("1"),
-        "cm" => BigDecimal("100"),
-        "dm" => BigDecimal("10"),
-        "mm" => BigDecimal("1000")
-      },
-      "cm" => {
-        "cm" => BigDecimal("1"),
-        "dm" => BigDecimal("0.1"),
-        "m"  => BigDecimal("0.01"),
-        "mm" => BigDecimal("10")
-      },
-      "dm" => {
-        "dm" => BigDecimal("1"),
-        "cm" => BigDecimal("10"),
-        "m"  => BigDecimal("0.1"),
-        "mm" => BigDecimal("100")
-      },
-      "mm" => {
-        "mm" => BigDecimal("1"),
-        "m"  => BigDecimal("0.001"),
-        "dm"  => BigDecimal("0.01"),
-        "cm" => BigDecimal("0.1")
-      }
-    }
-
-    assert_equal expected, @conversion.conversion_table
-  end
-
-end