j-law-ruby 0.0.3

data/test/test_gemspec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "json"
+require "minitest/autorun"
+require "open3"
+require "fileutils"
+require "bundler"
+require_relative "../lib/j_law_ruby/build_support"
+
+class TestGemspec < Minitest::Test
+  GEM_ROOT = File.expand_path("..", __dir__)
+
+  def test_source_gem_keeps_ruby_platform_and_extension_build
+    spec = with_native_library_placeholder { load_gemspec(binary: false) }
+
+    assert_equal Gem::Platform::RUBY, spec.fetch("platform")
+    assert_equal ["ext/j_law_ruby/extconf.rb"], spec.fetch("extensions")
+    refute_includes spec.fetch("files"), native_library_path
+  end
+
+  def test_binary_gem_is_platform_specific_and_bundles_native_library
+    spec = with_native_library_placeholder { load_gemspec(binary: true) }
+
+    assert_equal Gem::Platform.local.to_s, spec.fetch("platform")
+    assert_empty spec.fetch("extensions")
+    assert_includes spec.fetch("files"), native_library_path
+  end
+
+  private
+
+  def load_gemspec(binary:)
+    script = <<~RUBY
+      require "json"
+
+      spec = Gem::Specification.load("j_law_ruby.gemspec")
+      abort "failed to load gemspec" if spec.nil?
+
+      puts JSON.generate(
+        platform: spec.platform.to_s,
+        extensions: spec.extensions,
+        files: spec.files.sort
+      )
+    RUBY
+
+    stdout = nil
+    stderr = nil
+    status = nil
+
+    Bundler.with_unbundled_env do
+      stdout, stderr, status = Open3.capture3(
+        { JLawRuby::BuildSupport::BINARY_GEM_ENV => (binary ? "1" : "0") },
+        "ruby",
+        "-e",
+        script,
+        chdir: GEM_ROOT
+      )
+    end
+
+    assert status.success?, stderr
+
+    JSON.parse(stdout)
+  end
+
+  def native_library_path
+    File.join(
+      "lib",
+      "j_law_ruby",
+      "native",
+      JLawRuby::BuildSupport.shared_library_filename
+    )
+  end
+
+  def with_native_library_placeholder
+    path = File.join(GEM_ROOT, native_library_path)
+    created = !File.exist?(path)
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, "") if created
+    yield
+  ensure
+    FileUtils.rm_f(path) if created
+  end
+end

data/test/test_income_tax.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# 所得税法第89条に基づく所得税計算のテスト。
+#
+# 法的根拠: 所得税法 第89条第1項 / 復興財源確保法 第13条
+# テストケースは tests/fixtures/income_tax.json から読み込む。
+#
+# 実行方法:
+#   rake compile && ruby -Ilib test/test_income_tax.rb
+
+require "minitest/autorun"
+require "json"
+require "date"
+require "j_law_ruby"
+
+INCOME_TAX_FIXTURES = JSON.parse(
+  File.read(File.join(__dir__, "../../../tests/fixtures/income_tax.json"))
+)
+
+# ─── データ駆動テスト ─────────────────────────────────────────────────────────
+
+class TestIncomeTaxFixtures < Minitest::Test
+  INCOME_TAX_FIXTURES["income_tax"].each do |c|
+    define_method("test_#{c['id']}") do
+      inp = c["input"]
+      exp = c["expected"]
+
+      date = Date.parse(inp["date"])
+      r = JLawRuby::IncomeTax.calc_income_tax(
+        inp["taxable_income"], date,
+        inp["apply_reconstruction_tax"]
+      )
+
+      assert_equal exp["base_tax"], r.base_tax, "#{c['id']}: base_tax"
+      assert_equal exp["reconstruction_tax"], r.reconstruction_tax, "#{c['id']}: reconstruction_tax"
+      assert_equal exp["total_tax"], r.total_tax, "#{c['id']}: total_tax"
+      if exp["reconstruction_tax_applied"]
+        assert r.reconstruction_tax_applied?, "#{c['id']}: reconstruction_tax_applied"
+      else
+        refute r.reconstruction_tax_applied?, "#{c['id']}: reconstruction_tax_applied"
+      end
+    end
+  end
+end
+
+# ─── 言語固有テスト ──────────────────────────────────────────────────────────
+
+class TestIncomeTaxLanguageSpecific < Minitest::Test
+  def test_error_date_out_of_range
+    assert_raises(RuntimeError) do
+      JLawRuby::IncomeTax.calc_income_tax(5_000_000, Date.new(1988, 12, 31), true)
+    end
+  end
+
+  def test_breakdown_fields
+    r = JLawRuby::IncomeTax.calc_income_tax(5_000_000, Date.new(2024, 1, 1), true)
+    refute_empty r.breakdown
+    r.breakdown.each do |step|
+      refute_empty step[:label]
+      assert_operator step[:rate_denom], :>, 0
+    end
+  end
+
+  def test_inspect
+    r = JLawRuby::IncomeTax.calc_income_tax(5_000_000, Date.new(2024, 1, 1), true)
+    assert_match(/IncomeTaxResult/, r.inspect)
+  end
+
+  def test_type_error_invalid_date
+    assert_raises(TypeError) do
+      JLawRuby::IncomeTax.calc_income_tax(5_000_000, "2024-01-01", true)
+    end
+    assert_raises(TypeError) do
+      JLawRuby::IncomeTax.calc_income_tax(5_000_000, 20_240_101, true)
+    end
+  end
+end

data/test/test_income_tax_deductions.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "json"
+require "date"
+require "j_law_ruby"
+
+FIXTURES = JSON.parse(
+  File.read(File.join(__dir__, "../../../tests/fixtures/income_tax_deductions.json"))
+)
+
+def build_input(input)
+  {
+    spouse: input["spouse"] && {
+      spouse_total_income_amount: input["spouse"]["spouse_total_income_amount"],
+      is_same_household: input["spouse"]["is_same_household"],
+      is_elderly: input["spouse"]["is_elderly"],
+    },
+    dependent: {
+      general_count: input.fetch("dependent", {}).fetch("general_count", 0),
+      specific_count: input.fetch("dependent", {}).fetch("specific_count", 0),
+      elderly_cohabiting_count: input.fetch("dependent", {}).fetch("elderly_cohabiting_count", 0),
+      elderly_other_count: input.fetch("dependent", {}).fetch("elderly_other_count", 0),
+    },
+    social_insurance_premium_paid: input.fetch("social_insurance_premium_paid", 0),
+    medical: input["medical"] && {
+      medical_expense_paid: input["medical"]["medical_expense_paid"],
+      reimbursed_amount: input["medical"]["reimbursed_amount"],
+    },
+    life_insurance: input["life_insurance"] && {
+      new_general_paid_amount: input["life_insurance"]["new_general_paid_amount"],
+      new_individual_pension_paid_amount: input["life_insurance"]["new_individual_pension_paid_amount"],
+      new_care_medical_paid_amount: input["life_insurance"]["new_care_medical_paid_amount"],
+      old_general_paid_amount: input["life_insurance"]["old_general_paid_amount"],
+      old_individual_pension_paid_amount: input["life_insurance"]["old_individual_pension_paid_amount"],
+    },
+    donation: input["donation"] && {
+      qualified_donation_amount: input["donation"]["qualified_donation_amount"],
+    },
+  }
+end
+
+class TestIncomeTaxDeductionsFixtures < Minitest::Test
+  FIXTURES["income_tax_deductions"].each do |c|
+    define_method("test_#{c['id']}") do
+      inp = c["input"]
+      exp = c["expected"]
+
+      result = JLawRuby::IncomeTax.calc_income_deductions(
+        inp["total_income_amount"],
+        Date.parse(inp["date"]),
+        **build_input(inp)
+      )
+
+      assert_equal exp["total_income_amount"], result.total_income_amount
+      assert_equal exp["total_deductions"], result.total_deductions
+      assert_equal exp["taxable_income_before_truncation"], result.taxable_income_before_truncation
+      assert_equal exp["taxable_income"], result.taxable_income
+    end
+  end
+end
+
+class TestIncomeTaxAssessmentFixtures < Minitest::Test
+  FIXTURES["income_tax_assessment"].each do |c|
+    define_method("test_#{c['id']}") do
+      inp = c["input"]
+      exp = c["expected"]
+
+      result = JLawRuby::IncomeTax.calc_income_tax_assessment(
+        inp["total_income_amount"],
+        Date.parse(inp["date"]),
+        apply_reconstruction_tax: inp["apply_reconstruction_tax"],
+        **build_input(inp)
+      )
+
+      assert_equal exp["taxable_income"], result.deductions.taxable_income
+      assert_equal exp["base_tax"], result.tax.base_tax
+      assert_equal exp["reconstruction_tax"], result.tax.reconstruction_tax
+      assert_equal exp["total_tax"], result.tax.total_tax
+    end
+  end
+end

data/test/test_real_estate.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# 宅建業法第46条に基づく媒介報酬計算のテスト。
+#
+# 法的根拠: 宅地建物取引業法 第46条第1項 / 国土交通省告示
+# テストケースは tests/fixtures/real_estate.json から読み込む。
+#
+# 実行方法:
+#   rake compile && ruby -Ilib test/test_real_estate.rb
+
+require "minitest/autorun"
+require "json"
+require "date"
+require "j_law_ruby"
+
+REAL_ESTATE_FIXTURES = JSON.parse(
+  File.read(File.join(__dir__, "../../../tests/fixtures/real_estate.json"))
+)
+
+# ─── データ駆動テスト ─────────────────────────────────────────────────────────
+
+class TestBrokerageFeeFixtures < Minitest::Test
+  REAL_ESTATE_FIXTURES["brokerage_fee"].each do |c|
+    define_method("test_#{c['id']}") do
+      inp = c["input"]
+      exp = c["expected"]
+
+      date = Date.parse(inp["date"])
+      r = JLawRuby::RealEstate.calc_brokerage_fee(
+        inp["price"], date,
+        inp["is_low_cost_vacant_house"], inp.fetch("is_seller", false)
+      )
+
+      if exp.key?("total_without_tax")
+        assert_equal exp["total_without_tax"], r.total_without_tax, "#{c['id']}: total_without_tax"
+      end
+      if exp.key?("tax_amount")
+        assert_equal exp["tax_amount"], r.tax_amount, "#{c['id']}: tax_amount"
+      end
+      if exp.key?("total_with_tax")
+        assert_equal exp["total_with_tax"], r.total_with_tax, "#{c['id']}: total_with_tax"
+      end
+      if exp.key?("low_cost_special_applied")
+        if exp["low_cost_special_applied"]
+          assert r.low_cost_special_applied?, "#{c['id']}: low_cost_special_applied"
+        else
+          refute r.low_cost_special_applied?, "#{c['id']}: low_cost_special_applied"
+        end
+      end
+      if exp.key?("breakdown_results")
+        actual = r.breakdown.map { |step| step[:result] }
+        assert_equal exp["breakdown_results"], actual, "#{c['id']}: breakdown_results"
+      end
+    end
+  end
+end
+
+# ─── 言語固有テスト ──────────────────────────────────────────────────────────
+
+class TestBrokerageFeeLanguageSpecific < Minitest::Test
+  def test_error_date_out_of_range
+    # 1970-12-01 施行のため、それ以前の日付はエラー
+    err = assert_raises(RuntimeError) do
+      JLawRuby::RealEstate.calc_brokerage_fee(5_000_000, Date.new(1970, 11, 30), false, false)
+    end
+    assert_match(/1970-11-30/, err.message)
+  end
+
+  def test_breakdown_fields
+    r = JLawRuby::RealEstate.calc_brokerage_fee(5_000_000, Date.new(2024, 8, 1), false, false)
+    r.breakdown.each do |step|
+      refute_empty step[:label]
+      assert_operator step[:rate_denom], :>, 0
+    end
+  end
+
+  def test_inspect
+    r = JLawRuby::RealEstate.calc_brokerage_fee(5_000_000, Date.new(2024, 8, 1), false, false)
+    assert_match(/BrokerageFeeResult/, r.inspect)
+  end
+
+  def test_type_error_invalid_date
+    assert_raises(TypeError) do
+      JLawRuby::RealEstate.calc_brokerage_fee(5_000_000, "2024-08-01", false, false)
+    end
+    assert_raises(TypeError) do
+      JLawRuby::RealEstate.calc_brokerage_fee(5_000_000, 20_240_801, false, false)
+    end
+  end
+
+  def test_negative_price_is_rejected
+    error = assert_raises(ArgumentError) do
+      JLawRuby::RealEstate.calc_brokerage_fee(-1, Date.new(2024, 8, 1), false, false)
+    end
+
+    assert_match(/price/, error.message)
+  end
+end

data/test/test_stamp_tax.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "json"
+require "date"
+require "j_law_ruby"
+
+class TestStampTax < Minitest::Test
+  FIXTURES = JSON.parse(File.read(File.join(__dir__, "../../../tests/fixtures/stamp_tax.json")))
+
+  FIXTURES["stamp_tax"].each do |tc|
+    define_method("test_#{tc['id']}") do
+      inp = tc["input"]
+      exp = tc["expected"]
+
+      date = Date.parse(inp["date"])
+      result = JLawRuby::StampTax.calc_stamp_tax(
+        inp["document_code"],
+        inp["stated_amount"],
+        date,
+        flags: inp["flags"]
+      )
+
+      assert_equal exp["tax_amount"], result.tax_amount, "#{tc['id']}: tax_amount"
+      assert_equal exp["rule_label"], result.rule_label, "#{tc['id']}: rule_label"
+      if exp["applied_special_rule"].nil?
+        assert_nil result.applied_special_rule, "#{tc['id']}: applied_special_rule"
+      else
+        assert_equal exp["applied_special_rule"], result.applied_special_rule, "#{tc['id']}: applied_special_rule"
+      end
+    end
+  end
+
+  def test_error_date_out_of_range
+    err = assert_raises(RuntimeError) do
+      JLawRuby::StampTax.calc_stamp_tax("article1_real_estate_transfer", 5_000_000, Date.new(2014, 3, 31))
+    end
+    assert_match(/2014-03-31/, err.message)
+  end
+
+  def test_inspect
+    result = JLawRuby::StampTax.calc_stamp_tax("article1_real_estate_transfer", 5_000_000, Date.new(2024, 8, 1))
+    assert_match(/StampTaxResult/, result.inspect)
+  end
+
+  def test_type_error_invalid_date
+    assert_raises(TypeError) do
+      JLawRuby::StampTax.calc_stamp_tax("article1_real_estate_transfer", 5_000_000, "2024-08-01")
+    end
+  end
+
+  def test_invalid_document_code
+    assert_raises(ArgumentError) do
+      JLawRuby::StampTax.calc_stamp_tax("invalid_code", 5_000_000, Date.new(2024, 8, 1))
+    end
+  end
+
+  def test_invalid_flag
+    assert_raises(ArgumentError) do
+      JLawRuby::StampTax.calc_stamp_tax(
+        "article17_sales_receipt",
+        70_000,
+        Date.new(2024, 8, 1),
+        flags: ["invalid_flag"]
+      )
+    end
+  end
+end

data/test/test_withholding_tax.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "json"
+require "date"
+require "j_law_ruby"
+
+class TestWithholdingTax < Minitest::Test
+  FIXTURES = JSON.parse(File.read(File.join(__dir__, "../../../tests/fixtures/withholding_tax.json")))
+
+  FIXTURES["withholding_tax"].each do |tc|
+    define_method("test_#{tc['id']}") do
+      inp = tc["input"]
+      exp = tc["expected"]
+
+      result = JLawRuby::WithholdingTax.calc_withholding_tax(
+        inp["payment_amount"],
+        Date.parse(inp["date"]),
+        inp["category"],
+        is_submission_prize: inp["is_submission_prize"],
+        separated_consumption_tax_amount: inp["separated_consumption_tax_amount"]
+      )
+
+      assert_equal exp["taxable_payment_amount"], result.taxable_payment_amount
+      assert_equal exp["tax_amount"], result.tax_amount
+      assert_equal exp["net_payment_amount"], result.net_payment_amount
+      assert_equal exp["submission_prize_exempted"], result.submission_prize_exempted?
+    end
+  end
+
+  def test_out_of_range_date
+    assert_raises(RuntimeError) do
+      JLawRuby::WithholdingTax.calc_withholding_tax(
+        100_000,
+        Date.new(2012, 12, 31),
+        :manuscript_and_lecture
+      )
+    end
+  end
+
+  def test_breakdown_fields
+    result = JLawRuby::WithholdingTax.calc_withholding_tax(
+      1_500_000,
+      Date.new(2026, 1, 1),
+      :professional_fee
+    )
+    assert_equal 2, result.breakdown.length
+    refute_empty result.breakdown.first[:label]
+  end
+
+  def test_inspect
+    result = JLawRuby::WithholdingTax.calc_withholding_tax(
+      100_000,
+      Date.new(2026, 1, 1),
+      :manuscript_and_lecture
+    )
+    assert_match(/WithholdingTaxResult/, result.inspect)
+  end
+
+  def test_type_error_invalid_date
+    assert_raises(TypeError) do
+      JLawRuby::WithholdingTax.calc_withholding_tax(100_000, "2026-01-01", :professional_fee)
+    end
+  end
+end