You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
499 lines
19 KiB
499 lines
19 KiB
require File.dirname(__FILE__) + '/test_helper'
|
|
|
|
class DinheiroTest < Test::Unit::TestCase
|
|
|
|
CONTABIL = { "(2,00)" => -2,
|
|
"2,00" => 2,
|
|
"0,00" => 0,
|
|
"0,32" => 0.32,
|
|
"(0,01)" => -0.01 }
|
|
|
|
REAL_CONTABIL = { "R$ (1,00)" => -1,
|
|
"R$ (0,12)" => -0.12,
|
|
"R$ 1,00" => 1,
|
|
"R$ 1,00" => 1,
|
|
"R$ 1,00" => 1,
|
|
"R$ 0,00" => 0 }
|
|
|
|
SOMA = { 0.real => 0.real + 0.real,
|
|
1.real => 0.real + 1.real,
|
|
1.real => 1.real + 0.real,
|
|
2.reais => 1.real + 1.real,
|
|
2.reais => 0.real + 2.reais,
|
|
2.reais => 2.reais + 0.real,
|
|
0.real => 2.real + -2.real,
|
|
0.real => 0.real + BigDecimal.new("0"),
|
|
0.3.real => 0.real + 0.3.real,
|
|
-0.3.real => 0.real + -0.3.real,
|
|
-0.03.real => 0 + -0.03.real,
|
|
-0.03.real => 0.real + -0.03,
|
|
-1.03.real => -1.real + -0.03,
|
|
-1.03.real => -1.real + BigDecimal.new("-0.03") }
|
|
|
|
SUBTRACAO = { 0.real => 0.real - 0.real,
|
|
-1.real => 0.real - 1.real,
|
|
1.real => 1.real - 0.real,
|
|
0.real => 1.real - 1.real,
|
|
-2.reais => 0.real - 2.reais,
|
|
2.reais => 2.reais - 0.real,
|
|
-4.reais => -2.reais - 2.reais,
|
|
0.3.real => 0.3.real - 0.real,
|
|
0.03.real => 0.03.real - 0.real,
|
|
0.03.real => 0.06.real - 0.03.real,
|
|
-0.03.real => 0 - 0.03.real,
|
|
-0.03.real => 0.real - 0.03,
|
|
-1.03.real => -1.real - 0.03,
|
|
-1.03.real => -1.real - BigDecimal.new("0.03") }
|
|
|
|
MULTIPLICACAO = { 0.real => 0.real * 0,
|
|
0.real => 0.real * 1,
|
|
0.real => 0.real * -1,
|
|
1.real => 1.real * 1,
|
|
10.real => 10.real * 1,
|
|
100.real => 100.real * 1,
|
|
1000.real => 1000.real * 1,
|
|
1.real => -1.real * -1,
|
|
-1.real => 1.real * -1,
|
|
-1.real => -1.real * 1,
|
|
0.1.real => 1.real * 0.1,
|
|
0.01.real => 1.real * 0.01,
|
|
0.01.real => 1.real * 0.009,
|
|
0.01.real => 1.real * 0.005,
|
|
0.00.real => 1.real * 0.0049,
|
|
0.1.real => 0.1.real * 1,
|
|
0.01.real => 0.01.real * 1,
|
|
0.01.real => 0.009.real * 1,
|
|
0.00.real => 0.00049.real * 1,
|
|
0.real => 0.real * 0.real,
|
|
0.real => 0.real * BigDecimal("0"),
|
|
1.real => 1.real * 1.real,
|
|
1.real => 1.real * BigDecimal("1"),
|
|
1.real => 0.5.real * 2.real,
|
|
1.real => 0.5.real * BigDecimal("2"),
|
|
1.real => 1 * 1.real,
|
|
-1.real => -1 * 1.real,
|
|
1.real => -1 * -1.real,
|
|
0.01.real => 0.01 * 1.real,
|
|
0.01.real => 1.real * BigDecimal("0.01"),
|
|
0.01.real => BigDecimal("0.01") * 1.real }
|
|
|
|
DIVISAO = {
|
|
Dinheiro.new(0.33) => Dinheiro.new(1) / 3,
|
|
Dinheiro.new(33.33) => Dinheiro.new(100) / 3,
|
|
Dinheiro.new(50.00) => Dinheiro.new(100) / 2,
|
|
Dinheiro.new(0.25) => Dinheiro.new(0.5) / 2,
|
|
Dinheiro.new(0.17) => Dinheiro.new(0.5) / 3,
|
|
Dinheiro.new(0.33) => Dinheiro.new(0.33) / 1
|
|
}
|
|
|
|
PARCELAS = {
|
|
[Dinheiro.new(0.33), Dinheiro.new(0.33), Dinheiro.new(0.34)] => Dinheiro.new(1).parcelar(3),
|
|
[Dinheiro.new(33.33), Dinheiro.new(33.33), Dinheiro.new(33.34)] => Dinheiro.new(100).parcelar(3),
|
|
[Dinheiro.new(50.00), Dinheiro.new(50)] => Dinheiro.new(100).parcelar(2),
|
|
[Dinheiro.new(0.25), Dinheiro.new(0.25)] => Dinheiro.new(0.5).parcelar(2),
|
|
[Dinheiro.new(0.16), Dinheiro.new(0.17),Dinheiro.new(0.17)] => Dinheiro.new(0.5).parcelar(3),
|
|
[Dinheiro.new(0.33)] => Dinheiro.new(0.33).parcelar(1),
|
|
[Dinheiro.new(0.33)] => Dinheiro.new(0.33).parcelar(1),
|
|
}
|
|
|
|
|
|
QUANTIA_COM_FORMATO_VALIDO = [ "1211",
|
|
"1211.",
|
|
"1211.0",
|
|
"1211.23",
|
|
"1211,23",
|
|
"1.211",
|
|
"1.211,00",
|
|
"1.211,01",
|
|
"1.211,1",
|
|
"1.211,",
|
|
"1,",
|
|
"12,",
|
|
"32349898989912,",
|
|
"32.349.898.989.912,",
|
|
"32.349.898.989.912,1",
|
|
"32.349.898.989.912,12",
|
|
"1",
|
|
"1.00",
|
|
"1.01",
|
|
"1.1",
|
|
"1.",
|
|
".1",
|
|
".12",
|
|
"0.12",
|
|
"1.12",
|
|
"12.12",
|
|
"12.12",
|
|
"123.12",
|
|
"1,234.12",
|
|
"12,234.12",
|
|
"123,234.12",
|
|
"2,123,234.12",
|
|
",1",
|
|
",11",
|
|
",01",
|
|
"0,01" ]
|
|
QUANTIA_COM_FORMATO_INVALIDO = [ 'teste',
|
|
'12,123,99',
|
|
'12.123.99',
|
|
'1,123,99',
|
|
'1212,39.90' ]
|
|
|
|
COMPARACAO = [ 1.real < 2.reais,
|
|
1.real <= 2.reais,
|
|
2.real > 1.real,
|
|
2.real >= 1.real,
|
|
1.real == 1.real,
|
|
1.real >= 1.real,
|
|
1.real <= 1.real ]
|
|
|
|
COMPARACAO_COM_ESCALAR = [ 1.real < 2.00,
|
|
1.real <= 2.00,
|
|
2.real > 1.00,
|
|
2.real >= 1.00,
|
|
1.real == 1.00,
|
|
1.real >= 1.00,
|
|
1.real <= 1.00 ]
|
|
|
|
ARREDONDAMENTO = { 23049 => 230.49,
|
|
23049 => 230.4949999999,
|
|
23050 => 230.495 }
|
|
|
|
PONTO_NO_MILHAR = { "234.175.211" => "234175211",
|
|
"" => "",
|
|
"1" => "1",
|
|
"12" => "12",
|
|
"123" => "123",
|
|
"1.234" => "1234",
|
|
"12.345" => "12345",
|
|
"123.456" => "123456",
|
|
"123.112.211" => "123112211",
|
|
"1.234.567" => "1234567" }
|
|
|
|
QUANTIA_VALIDA = { "0,00" => 0 ,
|
|
"0,00" => 0.0 ,
|
|
"0,00" => "0" ,
|
|
"0,00" => "0,00" ,
|
|
"1,00" => 1 ,
|
|
"1,03" => 1.03 ,
|
|
"1,03" => "1,03" ,
|
|
"0,03" => ",03" ,
|
|
"0,30" => ",3" ,
|
|
"0,03" => ".03" ,
|
|
"0,30" => ".3" ,
|
|
"-0,30" => -0.3 ,
|
|
"-0,03" => -0.03 ,
|
|
"1,00" => "1,00" ,
|
|
"-1,00" => -1 ,
|
|
"-1,00" => -1.0 ,
|
|
"-1,00" => "-1" ,
|
|
"-1,00" => "-1,00" ,
|
|
"-2,30" => "-2,30" ,
|
|
"2,30" => "2,30" ,
|
|
"2,30" => 2.30 ,
|
|
"2,30" => 2.3 ,
|
|
"1.211,00" => "1211,00" ,
|
|
"1.211,01" => "1211,01" ,
|
|
"1.211,50" => "1211,5" ,
|
|
"1.211,00" => "1211," ,
|
|
"1.211,00" => "1211" ,
|
|
"1.211,00" => "1211.00" ,
|
|
"1.211,01" => "1211.01" ,
|
|
"1.211,20" => "1211.2" ,
|
|
"1.211,00" => "1211." ,
|
|
"1.211,00" => "1211" ,
|
|
"1.211,00" => "1.211" ,
|
|
"123.112.211,35" => "123112211,35" ,
|
|
"-123.112.211,35" => "-123112211,35" ,
|
|
"123.112.211,35" => "+123112211,35" }
|
|
|
|
PARTE_INTEIRA = [ -1, -123112211, 0, 1, 12344545 ]
|
|
|
|
|
|
def setup
|
|
tornar_metodos_publicos Dinheiro
|
|
@dinheiro = 1.real
|
|
end
|
|
|
|
def testa_se_cria_dinheiro_a_partir_de_quantias_validos
|
|
QUANTIA_VALIDA.each do |esperado, quantia|
|
|
assert_equal esperado, Dinheiro.new(quantia).to_s, "Deveria ter vindo o quantia: #{esperado} quando recebeu #{quantia}"
|
|
end
|
|
end
|
|
|
|
# coloca_ponto_no_milhar
|
|
def testa_se_coloca_ponto_no_milhar
|
|
PONTO_NO_MILHAR.each do |esperado, quantia|
|
|
{ esperado => quantia,
|
|
"-#{esperado}" => "-#{quantia}" }.each do |esperado, quantia|
|
|
assert_equal esperado, @dinheiro.inteiro_com_milhar(quantia)
|
|
end
|
|
end
|
|
end
|
|
|
|
def testa_to_s
|
|
assert_equal "1,00", Dinheiro.new(1).to_s
|
|
assert_equal "1.000,00", Dinheiro.new(1000).to_s
|
|
end
|
|
|
|
# real
|
|
def testa_real_nao_eh_dinheiro
|
|
assert_kind_of(Dinheiro, 1.real)
|
|
end
|
|
|
|
def testa_real_eh_dinheiro
|
|
assert_kind_of(Dinheiro, Dinheiro.new(1).real)
|
|
end
|
|
|
|
def testa_real_contabil
|
|
REAL_CONTABIL.each { |esperado, quantia| assert_equal esperado, Dinheiro.new(quantia).real_contabil }
|
|
end
|
|
|
|
def testa_reais_contabeis
|
|
REAL_CONTABIL.each { |esperado, quantia| assert_equal esperado, Dinheiro.new(quantia).reais_contabeis }
|
|
end
|
|
|
|
# reais
|
|
def testa_reais
|
|
assert_equal Dinheiro.new("2,00"), Dinheiro.new(2).reais
|
|
end
|
|
|
|
def testa_contabil
|
|
CONTABIL.each { |esperado, quantia| assert_equal esperado, Dinheiro.new(quantia).contabil }
|
|
end
|
|
|
|
# real_formatado
|
|
def test_real_formatado
|
|
assert_equal "R$ 2,00", Dinheiro.new(2).real_formatado
|
|
end
|
|
|
|
# ==
|
|
def testa_igualdade
|
|
assert_equal Dinheiro.new(1), Dinheiro.new(1)
|
|
end
|
|
|
|
def testa_igualdade_quando_passa_possivel_dinheiro
|
|
assert_equal Dinheiro.new(1), 1.0
|
|
end
|
|
|
|
def testa_igualdade_quando_passa_algo_que_nao_seja_dinheiro
|
|
assert_equal false, Dinheiro.new(1) == 'salario'
|
|
end
|
|
|
|
# / (divisao)
|
|
def testa_divisao
|
|
DIVISAO.each { |parcelas, divisao| assert_equal parcelas, divisao }
|
|
end
|
|
|
|
def testa_divisao_por_zero
|
|
assert_raise(ZeroDivisionError) { 1.real / 0 }
|
|
end
|
|
|
|
def testa_divisao_por_algo_que_nao_seja_um_escalar
|
|
assert_raise(DivisaPorNaoEscalarError) { 10.reais / 2.reais }
|
|
end
|
|
|
|
# parcelar
|
|
def testa_parcelar
|
|
PARCELAS.each { |parcelas, divisao| assert_equal parcelas, divisao }
|
|
end
|
|
|
|
def testa_parcelar_por_zero
|
|
assert_raise(ZeroDivisionError) { 1.real.parcelar 0 }
|
|
end
|
|
|
|
def testa_parcelar_por_algo_que_nao_seja_um_escalar
|
|
assert_raise(DivisaPorNaoEscalarError) { 10.reais.parcelar(2.reais) }
|
|
end
|
|
|
|
# initialize
|
|
def testa_se_cria_dinheiro_a_partir_de_float
|
|
verifica_se_cria_dinheiro_para 1.0
|
|
end
|
|
|
|
def testa_se_cria_dinheiro_a_partir_de_fixnum
|
|
verifica_se_cria_dinheiro_para 1
|
|
end
|
|
|
|
def testa_se_cria_dinheiro_a_partir_de_bigdecimal
|
|
verifica_se_cria_dinheiro_para BigDecimal.new("1")
|
|
end
|
|
|
|
def testa_se_cria_dinheiro_a_partir_de_string
|
|
verifica_se_cria_dinheiro_para "1"
|
|
end
|
|
|
|
def testa_se_rejeita_criacao_de_dinheiro_a_partir_de_string_invalida
|
|
QUANTIA_COM_FORMATO_INVALIDO.each do |quantia|
|
|
assert_raise DinheiroInvalidoError, "Deveria ter rejeitado [#{quantia}]" do
|
|
Dinheiro.new quantia
|
|
end
|
|
end
|
|
end
|
|
|
|
# + (soma)
|
|
def testa_soma
|
|
SOMA.each{ |esperado, soma| assert_equal esperado, soma }
|
|
end
|
|
|
|
# - (subtracao)
|
|
def testa_subtracao
|
|
SUBTRACAO.each { |esperado, subtracao| assert_equal esperado, subtracao }
|
|
end
|
|
|
|
# * (multiplicacao)
|
|
def testa_multiplicacao
|
|
MULTIPLICACAO.each { |esperado, multiplicacao| assert_equal esperado, multiplicacao }
|
|
end
|
|
|
|
# quantia_de
|
|
def testa_quantia_de
|
|
assert_equal 0, @dinheiro.quantia_de(0.real)
|
|
assert_equal 0, @dinheiro.quantia_de(0)
|
|
end
|
|
|
|
#por_extenso
|
|
def testa_por_extenso
|
|
assert_equal 'um real', 1.real.por_extenso
|
|
assert_equal 'um centavo', (0.01).real.por_extenso
|
|
assert_equal 'cem reais', 100.real.por_extenso
|
|
assert_equal 'cem reais e um centavo', (100.01).real.por_extenso
|
|
end
|
|
|
|
#por_extenso_em_reais
|
|
def testa_por_extenso_em_reais
|
|
assert_equal 'um real', 1.real.por_extenso_em_reais
|
|
assert_equal 'um centavo', (0.01).real.por_extenso_em_reais
|
|
assert_equal 'cem reais', 100.real.por_extenso_em_reais
|
|
assert_equal 'cem reais e um centavo', (100.01).real.por_extenso_em_reais
|
|
end
|
|
|
|
def testa_por_extenso_negativo
|
|
assert_equal 'um real negativo', -1.real.por_extenso_em_reais
|
|
assert_equal 'um centavo negativo', (-0.01).real.por_extenso_em_reais
|
|
assert_equal 'cem reais negativos', -100.real.por_extenso_em_reais
|
|
assert_equal 'cem reais e um centavo negativos', (-100.01).real.por_extenso_em_reais
|
|
assert_equal 'cento e dez reais negativos', (-110).real.por_extenso_em_reais
|
|
assert_equal 'vinte e dois reais negativos', -22.reais.por_extenso
|
|
assert_not_equal 'vinte e dois centavos negativos', -22.reais.por_extenso
|
|
assert_not_equal 'vinte e dois centavos', -22.reais.por_extenso
|
|
end
|
|
|
|
# to_f
|
|
def testa_to_f
|
|
assert_equal 2.30, 2.30.real.to_f
|
|
assert_equal 1000, 1000.real.to_f
|
|
end
|
|
|
|
# quantia_respeita_formato?
|
|
def testa_se_quantia_respeita_formato
|
|
QUANTIA_COM_FORMATO_VALIDO.each { |quantia| verifica_se_quantia_respeita_formato quantia }
|
|
end
|
|
|
|
# >, <, == (ordenacao)
|
|
def testa_comparacao_entre_dinheiro
|
|
COMPARACAO.each { |comparacao| assert comparacao }
|
|
end
|
|
|
|
def testa_comparacao_entre_possivel_dinheiro
|
|
COMPARACAO_COM_ESCALAR.each { |comparacao_com_escalar| assert comparacao_com_escalar }
|
|
end
|
|
|
|
# decimal
|
|
def testa_decimal_quando_todas_as_casas_estao_preenchidas
|
|
verifica_decimal("12")
|
|
end
|
|
|
|
def testa_decimal_quando_apenas_uma_das_casas_esta_preenchida
|
|
verifica_decimal("10", "1")
|
|
end
|
|
|
|
def testa_decimal_quando_nenhuma_das_casas_esta_preenchida
|
|
verifica_decimal("00", "")
|
|
end
|
|
|
|
def testa_se_transforma_em_string_que_represente_a_quantia_quando_tem_tres_digitos
|
|
verifica_se_transforma_em_string_corretamente "1.23", 123
|
|
end
|
|
|
|
def testa_se_transforma_em_string_que_represente_a_quantia_quando_tem_dois_digitos
|
|
verifica_se_transforma_em_string_corretamente "0.12", 12
|
|
end
|
|
|
|
def testa_se_transforma_em_string_que_represente_a_quantia_quando_tem_um_digito
|
|
verifica_se_transforma_em_string_corretamente "0.03", 3
|
|
end
|
|
|
|
def testa_se_transforma_em_string_para_valores_especiais
|
|
verifica_se_transforma_em_string_corretamente "-123112211.00", -12311221100
|
|
end
|
|
|
|
# parte_inteira
|
|
def testa_parte_inteira
|
|
PARTE_INTEIRA.each { |quantia| assert_equal "#{quantia}", Dinheiro.new(quantia).parte_inteira }
|
|
end
|
|
|
|
def testa_se_arredonda_valores_corretamente
|
|
ARREDONDAMENTO.each do |esperado, quantia|
|
|
assert_equal esperado, Dinheiro.new(quantia).quantia, "Deveria retornar #{esperado} para #{quantia}"
|
|
end
|
|
end
|
|
|
|
def testa_se_valor_decimal_cria_o_big_decimal_corretamente
|
|
assert_equal BigDecimal.new("1234.56"), Dinheiro.new("1234,56").valor_decimal
|
|
end
|
|
|
|
def testa_soma_de_dinheiro_com_big_decimal
|
|
assert_equal Dinheiro.new(200), BigDecimal.new("100").reais + "100".reais
|
|
end
|
|
|
|
def testa_zero_quando_eh_zero
|
|
assert Dinheiro.new(0).zero?
|
|
end
|
|
|
|
def testa_zero_quando_nao_eh_zero
|
|
assert !Dinheiro.new(1).zero?
|
|
end
|
|
|
|
private
|
|
|
|
def verifica_se_transforma_em_string_corretamente(quantia_esperada, quantia)
|
|
assert_equal quantia_esperada, @dinheiro.transforma_em_string_que_represente_a_quantia(quantia)
|
|
end
|
|
|
|
def verifica_decimal(esperado, quantia = esperado)
|
|
assert_equal esperado, @dinheiro.decimal("." + quantia)
|
|
assert_equal esperado, @dinheiro.decimal("," + quantia)
|
|
assert_equal esperado, @dinheiro.decimal(quantia) if quantia.blank?
|
|
end
|
|
|
|
def verifica_se_quantia_respeita_formato(quantia)
|
|
formatos_validos(quantia).each do |quantia_str|
|
|
assert 1.real.quantia_respeita_formato?(quantia_str), "O sistema deveria considerar o quantia '#{quantia_str}' dentro do formato valido."
|
|
end
|
|
end
|
|
|
|
def formatos_validos(quantia)
|
|
formatos_validos = []
|
|
quantias_validas(quantia).each do |quantia|
|
|
formatos_validos << quantia
|
|
[ "R$", "r$" ].each do |simbolo|
|
|
[ "", " ", " " ].each do |espacos|
|
|
formatos_validos << "#{simbolo}#{espacos}#{quantia}"
|
|
end
|
|
end
|
|
end
|
|
formatos_validos
|
|
end
|
|
|
|
def quantias_validas(quantia)
|
|
return [quantia] if [ ".", "," ].include?(quantia[0..0])
|
|
[ quantia, "-#{quantia}" ]
|
|
end
|
|
|
|
def verifica_se_cria_dinheiro_para(quantia)
|
|
assert quantia.para_dinheiro.kind_of?(Dinheiro)
|
|
end
|
|
|
|
end
|