j-law-ruby 0.0.3

data/vendor/rust/crates/j-law-core/src/domains/real_estate/calculator.rs

@@ -0,0 +1,197 @@
+use std::collections::HashSet;
+
+use crate::domains::consumption_tax::calculator::calculate_consumption_tax;
+use crate::domains::consumption_tax::context::ConsumptionTaxContext;
+use crate::domains::consumption_tax::policy::StandardConsumptionTaxPolicy;
+use crate::domains::real_estate::context::{RealEstateContext, RealEstateFlag};
+use crate::domains::real_estate::params::BrokerageFeeParams;
+use crate::error::{CalculationError, JLawError};
+use crate::types::amount::{FinalAmount, IntermediateAmount};
+use crate::types::rate::{MultiplyOrder, Rate};
+
+/// 1ティアの計算ステップ（内訳明細用）。
+#[derive(Debug, Clone)]
+pub struct BrokerageFeeStep {
+    pub label: String,
+    pub base_amount: u64,
+    pub rate_numer: u64,
+    pub rate_denom: u64,
+    pub result: FinalAmount,
+}
+
+/// 媒介報酬の計算結果。
+#[derive(Debug, Clone)]
+pub struct BrokerageFeeResult {
+    /// 税込合計額。
+    pub total_with_tax: FinalAmount,
+    /// 税抜合計額。
+    pub total_without_tax: FinalAmount,
+    /// 消費税額。
+    pub tax_amount: FinalAmount,
+    /// 各ティアの計算内訳。
+    pub breakdown: Vec<BrokerageFeeStep>,
+    /// 適用されたフラグ。
+    pub applied_flags: HashSet<RealEstateFlag>,
+    /// 低廉な空き家特例が適用されたか。
+    pub low_cost_special_applied: bool,
+}
+
+/// 宅建業法第46条に基づく媒介報酬を計算する。
+///
+/// # 法的根拠
+/// 宅地建物取引業法 第46条第1項
+/// 国土交通省告示（2024年7月1日施行 / 2019年10月1日施行）
+///
+/// # 計算手順
+/// 1. 各ティアの対象金額を求め、個別に切り捨てる
+/// 2. 各ティアの結果を合算して税抜き合計を得る
+/// 3. 低廉な空き家特例が適用される場合、通常計算が保証額を下回るなら保証額まで引き上げる
+///    （NOTE: `.max()` による最低保証であり、`.min()` による上限キャップではない）
+/// 4. 消費税ドメイン（消費税法第29条）に処理を委譲して税額・税込額を得る
+pub fn calculate_brokerage_fee(
+    ctx: &RealEstateContext,
+    params: &BrokerageFeeParams,
+) -> Result<BrokerageFeeResult, JLawError> {
+    ctx.target_date.validate()?;
+
+    let price = ctx.price;
+    let tier_rounding = ctx.policy.tier_rounding();
+
+    // --- ティア計算 ---
+    let mut breakdown: Vec<BrokerageFeeStep> = Vec::new();
+    let mut subtotal = 0u64;
+
+    for tier in &params.tiers {
+        let tier_base = compute_tier_base(price, tier.price_from, tier.price_to_inclusive);
+        if tier_base == 0 {
+            continue;
+        }
+
+        let rate = Rate::new(tier.rate_numer, tier.rate_denom).map_err(|_| {
+            CalculationError::Overflow {
+                step: tier.label.clone(),
+            }
+        })?;
+        let amount = IntermediateAmount::from_exact(tier_base);
+        let tier_result = rate.apply(&amount, MultiplyOrder::MultiplyFirst, tier_rounding)?;
+        let tier_final = tier_result.finalize(tier_rounding)?;
+
+        subtotal = subtotal.checked_add(tier_final.as_yen()).ok_or_else(|| {
+            CalculationError::Overflow {
+                step: tier.label.clone(),
+            }
+        })?;
+
+        breakdown.push(BrokerageFeeStep {
+            label: tier.label.clone(),
+            base_amount: tier_base,
+            rate_numer: tier.rate_numer,
+            rate_denom: tier.rate_denom,
+            result: tier_final,
+        });
+    }
+
+    // --- 低廉な空き家特例 ---
+    // 2018年1月1日施行（平成29年国土交通省告示第98号）。
+    // 400万円以下（2024年7月以降は800万円以下）の低廉な空き家等については、
+    // 通常計算が保証額を下回る場合でも保証額まで請求できる（最低保証額）。
+    //
+    // 適用条件（3つ全て満たす場合に適用）:
+    //   1. 売買価格が params.low_cost_special.price_ceiling_inclusive 以下
+    //   2. IsLowCostVacantHouse フラグが指定されている（ポリシーに委譲）
+    //   3. seller_only == true の場合は IsSeller フラグも必要（2018〜2024年の制約）
+    let mut low_cost_applied = false;
+    if let Some(special) = &params.low_cost_special {
+        let price_ok = price <= special.price_ceiling_inclusive;
+        let flag_ok = ctx.policy.should_apply_low_cost_special(&ctx.flags);
+        // seller_only の場合は IsSeller フラグが必須
+        let party_ok = !special.seller_only || ctx.flags.contains(&RealEstateFlag::IsSeller);
+        if price_ok && flag_ok && party_ok {
+            // fee_ceiling_exclusive_tax は法令上の「上限報酬額」だが、
+            // 特例適用時は「最低保証額」として機能する（通常計算が下回れば引き上げ）。
+            subtotal = subtotal.max(special.fee_ceiling_exclusive_tax);
+            low_cost_applied = true;
+        }
+    }
+
+    let total_without_tax = FinalAmount::new(subtotal);
+
+    // --- 消費税（消費税ドメインに委譲）---
+    let tax_ctx = ConsumptionTaxContext {
+        amount: subtotal,
+        target_date: ctx.target_date,
+        flags: HashSet::new(), // 不動産仲介報酬は標準税率のみ適用
+        policy: Box::new(StandardConsumptionTaxPolicy),
+    };
+    let tax_result = calculate_consumption_tax(&tax_ctx, &params.consumption_tax)?;
+
+    Ok(BrokerageFeeResult {
+        total_with_tax: tax_result.amount_with_tax,
+        total_without_tax,
+        tax_amount: tax_result.tax_amount,
+        breakdown,
+        applied_flags: ctx.flags.clone(),
+        low_cost_special_applied: low_cost_applied,
+    })
+}
+
+/// ティアに対応する課税対象金額（price のうちこのティア範囲に収まる部分）を返す。
+pub(crate) fn compute_tier_base(price: u64, from: u64, to_inclusive: Option<u64>) -> u64 {
+    if price < from {
+        return 0;
+    }
+    let capped = match to_inclusive {
+        Some(ceiling) => price.min(ceiling),
+        None => price,
+    };
+    if from == 0 {
+        capped
+    } else {
+        // `price_from` は前ティア上限の翌円を表す（例: tier2 は 2_000_001 から始まる）。
+        // そのため、このティアの課税対象金額は `capped - (from - 1)` で求まる。
+        capped - (from - 1)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tier_base_tier1_under() {
+        assert_eq!(compute_tier_base(1_000_000, 0, Some(2_000_000)), 1_000_000);
+    }
+
+    #[test]
+    fn tier_base_tier1_at_boundary() {
+        assert_eq!(compute_tier_base(2_000_000, 0, Some(2_000_000)), 2_000_000);
+    }
+
+    #[test]
+    fn tier_base_tier1_over() {
+        assert_eq!(compute_tier_base(5_000_000, 0, Some(2_000_000)), 2_000_000);
+    }
+
+    #[test]
+    fn tier_base_tier2_base() {
+        // 5,000,000円 の tier2（from=2,000,001, to=4,000,000）
+        // capped = min(5M, 4M) = 4M
+        // base = 4M - (2_000_001 - 1) = 4M - 2M = 2,000,000
+        assert_eq!(
+            compute_tier_base(5_000_000, 2_000_001, Some(4_000_000)),
+            2_000_000
+        );
+    }
+
+    #[test]
+    fn tier_base_price_below_from() {
+        assert_eq!(compute_tier_base(1_000_000, 2_000_001, Some(4_000_000)), 0);
+    }
+
+    #[test]
+    fn tier_base_no_ceiling() {
+        // 5,000,000円 の tier3（from=4,000,001, 上限なし）
+        // base = 5M - (4_000_001 - 1) = 5M - 4M = 1,000,000
+        assert_eq!(compute_tier_base(5_000_000, 4_000_001, None), 1_000_000);
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/real_estate/context.rs

@@ -0,0 +1,48 @@
+use crate::domains::real_estate::policy::RealEstatePolicy;
+use crate::types::date::LegalDate;
+use std::collections::HashSet;
+use std::fmt;
+
+/// 不動産取引計算に関わる法的フラグ。
+///
+/// WARNING: 各フラグの事実認定はライブラリの責任範囲外です。
+/// 呼び出し元が正しく判断した上で指定してください。
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum RealEstateFlag {
+    /// 低廉な空き家特例を申請する場合に指定する。
+    ///
+    /// 適用要件: 宅地建物取引業法 第46条 / 国土交通省告示（2018年1月1日施行・2024年7月1日改正）
+    /// WARNING: 対象物件が「低廉な空き家等」に該当するかの事実認定は呼び出し元の責任。
+    IsLowCostVacantHouse,
+    /// 売主側として報酬を計算する場合に指定する。
+    ///
+    /// 2018年1月1日〜2024年6月30日の低廉特例は売主のみに適用される。
+    /// このフラグが指定されない場合（買主側）、当該期間の特例は適用されない。
+    IsSeller,
+}
+
+/// 媒介報酬計算の入力コンテキスト。
+///
+/// # 法的根拠
+/// 宅地建物取引業法 第46条第1項
+pub struct RealEstateContext {
+    /// 売買価格（円）。
+    pub price: u64,
+    /// 契約日・適用する告示を選択するための基準日。
+    pub target_date: LegalDate,
+    /// 適用する法的フラグの集合。
+    pub flags: HashSet<RealEstateFlag>,
+    /// 計算ポリシー（テスト・カスタム計算での差し替えを可能にする）。
+    pub policy: Box<dyn RealEstatePolicy>,
+}
+
+impl fmt::Debug for RealEstateContext {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RealEstateContext")
+            .field("price", &self.price)
+            .field("target_date", &self.target_date)
+            .field("flags", &self.flags)
+            .field("policy", &"<policy>")
+            .finish()
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/real_estate/mod.rs

@@ -0,0 +1,9 @@
+pub mod calculator;
+pub mod context;
+pub mod params;
+pub mod policy;
+
+pub use calculator::{calculate_brokerage_fee, BrokerageFeeResult, BrokerageFeeStep};
+pub use context::{RealEstateContext, RealEstateFlag};
+pub use params::{BrokerageFeeParams, LowCostSpecialParams, TierParam};
+pub use policy::StandardMlitPolicy;

data/vendor/rust/crates/j-law-core/src/domains/real_estate/params.rs

@@ -0,0 +1,43 @@
+use crate::domains::consumption_tax::params::ConsumptionTaxParams;
+
+/// 1ティアの計算パラメータ。
+#[derive(Debug, Clone)]
+pub struct TierParam {
+    pub label: String,
+    pub price_from: u64,
+    /// `None` は上限なし。
+    pub price_to_inclusive: Option<u64>,
+    pub rate_numer: u64,
+    pub rate_denom: u64,
+}
+
+/// 低廉な空き家特例パラメータ。
+#[derive(Debug, Clone)]
+pub struct LowCostSpecialParams {
+    /// 特例対象となる売買価格の上限（この価格以下の場合に特例が適用される）。
+    pub price_ceiling_inclusive: u64,
+    /// 法令が定める報酬額の上限（税抜・円）。
+    ///
+    /// NOTE: フィールド名は法令上の「上限報酬額（ceiling）」を表すが、
+    /// 計算ロジックでは「最低保証額（floor）」として機能する。
+    /// 通常計算結果がこの値を下回る場合、この値まで引き上げられる。
+    /// 参照: `calculator::calculate_brokerage_fee` のコメント。
+    pub fee_ceiling_exclusive_tax: u64,
+    /// `true` の場合、売主側の取引にのみ特例が適用される。
+    ///
+    /// 2018年1月1日〜2024年6月30日の特例は売主のみ対象（宅建業法改正告示・平成29年国土交通省告示第98号）。
+    /// `false` の場合、売主・買主双方に適用される（2024年7月1日施行以降）。
+    pub seller_only: bool,
+}
+
+/// 媒介報酬計算に使うパラメータセット。
+///
+/// `j-law-registry` がJSONからロードしてこの型に変換する。
+/// `j-law-core` の計算ロジックはこの型のみに依存する。
+#[derive(Debug, Clone)]
+pub struct BrokerageFeeParams {
+    pub tiers: Vec<TierParam>,
+    /// 消費税パラメータ（消費税ドメインに処理を委譲する）。
+    pub consumption_tax: ConsumptionTaxParams,
+    pub low_cost_special: Option<LowCostSpecialParams>,
+}

data/vendor/rust/crates/j-law-core/src/domains/real_estate/policy.rs

@@ -0,0 +1,40 @@
+use crate::domains::real_estate::context::RealEstateFlag;
+use crate::types::rounding::RoundingStrategy;
+use std::collections::HashSet;
+
+/// 媒介報酬計算のポリシーインターフェース。
+///
+/// 端数処理戦略や特例適用の判定ロジックを差し替えられるようにする。
+/// 通常は [`StandardMlitPolicy`] を使う。
+///
+/// # 設計上の注意
+/// 価格の閾値チェック（`price_ceiling_inclusive`）は、
+/// パラメータレジストリが持つ値を使うため `calculator` 側で行う。
+/// このメソッドはフラグベースの判定のみを担う。
+pub trait RealEstatePolicy: std::fmt::Debug {
+    /// 低廉な空き家特例をフラグに基づいて適用するかどうかを判定する。
+    ///
+    /// 価格の閾値チェックは呼び出し元（`calculator`）がパラメータを用いて行う。
+    fn should_apply_low_cost_special(&self, flags: &HashSet<RealEstateFlag>) -> bool;
+
+    /// 各ティアの計算に使う端数処理戦略。
+    fn tier_rounding(&self) -> RoundingStrategy;
+}
+
+/// 国土交通省の標準解釈に基づく媒介報酬計算ポリシー。
+///
+/// # 法的根拠
+/// 宅地建物取引業法 第46条第1項
+/// 国土交通省告示（2018年1月1日施行・2024年7月1日改正）
+#[derive(Debug, Clone, Copy)]
+pub struct StandardMlitPolicy;
+
+impl RealEstatePolicy for StandardMlitPolicy {
+    fn should_apply_low_cost_special(&self, flags: &HashSet<RealEstateFlag>) -> bool {
+        flags.contains(&RealEstateFlag::IsLowCostVacantHouse)
+    }
+
+    fn tier_rounding(&self) -> RoundingStrategy {
+        RoundingStrategy::Floor
+    }
+}

data/vendor/rust/crates/j-law-core/src/domains/stamp_tax/calculator.rs

@@ -0,0 +1,321 @@
+use crate::domains::stamp_tax::context::{StampTaxContext, StampTaxFlag};
+use crate::domains::stamp_tax::params::{
+    StampTaxAmountUsage, StampTaxBracket, StampTaxChargeMode, StampTaxDocumentParams,
+    StampTaxParams, StampTaxSpecialRule,
+};
+use crate::error::{CalculationError, InputError, JLawError};
+use crate::types::amount::FinalAmount;
+
+/// 印紙税の計算内訳。
+#[derive(Debug, Clone)]
+pub struct StampTaxBreakdownStep {
+    pub rule_code: String,
+    pub label: String,
+    pub tax_amount: FinalAmount,
+}
+
+/// 印紙税の計算結果。
+///
+/// # 法的根拠
+/// 印紙税法 別表第一 / 租税特別措置法 第91条
+#[derive(Debug, Clone)]
+pub struct StampTaxResult {
+    pub tax_amount: FinalAmount,
+    pub rule_label: String,
+    pub applied_special_rule: Option<String>,
+    pub breakdown: Vec<StampTaxBreakdownStep>,
+}
+
+struct ResolvedTaxRule {
+    tax_amount: u64,
+    rule_label: String,
+}
+
+/// 印紙税法 別表第一に基づく印紙税額を計算する。
+pub fn calculate_stamp_tax(
+    ctx: &StampTaxContext,
+    params: &StampTaxParams,
+) -> Result<StampTaxResult, JLawError> {
+    ctx.target_date.validate()?;
+
+    let document = params.document_params(ctx.document_code).ok_or_else(|| {
+        InputError::InvalidStampTaxInput {
+            field: "document_code".into(),
+            reason: format!(
+                "対象文書コードのパラメータが存在しません: {}",
+                ctx.document_code
+            ),
+        }
+    })?;
+
+    validate_context(ctx, document)?;
+
+    let special_rule = ctx.policy.select_special_rule(ctx, document);
+    let (resolved, applied_special_rule, breakdown_rule_code) = match special_rule {
+        Some(rule) => (
+            resolve_special_rule(ctx, document, rule)?,
+            Some(rule.code.clone()),
+            rule.code.clone(),
+        ),
+        None => (resolve_base_rule(ctx, document)?, None, "base".into()),
+    };
+
+    Ok(StampTaxResult {
+        tax_amount: FinalAmount::new(resolved.tax_amount),
+        rule_label: resolved.rule_label.clone(),
+        applied_special_rule,
+        breakdown: vec![StampTaxBreakdownStep {
+            rule_code: breakdown_rule_code,
+            label: resolved.rule_label,
+            tax_amount: FinalAmount::new(resolved.tax_amount),
+        }],
+    })
+}
+
+fn validate_context(
+    ctx: &StampTaxContext,
+    document: &StampTaxDocumentParams,
+) -> Result<(), JLawError> {
+    match document.amount_usage {
+        StampTaxAmountUsage::Required if ctx.stated_amount.is_none() => {
+            return Err(InputError::InvalidStampTaxInput {
+                field: "stated_amount".into(),
+                reason: format!("{} には記載金額の指定が必要です", ctx.document_code),
+            }
+            .into());
+        }
+        StampTaxAmountUsage::Unsupported if ctx.stated_amount.is_some() => {
+            return Err(InputError::InvalidStampTaxInput {
+                field: "stated_amount".into(),
+                reason: format!("{} では記載金額を指定できません", ctx.document_code),
+            }
+            .into());
+        }
+        _ => {}
+    }
+
+    for flag in &ctx.flags {
+        validate_flag_for_document(*flag, ctx.document_code, ctx.stated_amount)?;
+    }
+
+    Ok(())
+}
+
+fn validate_flag_for_document(
+    flag: StampTaxFlag,
+    document_code: crate::domains::stamp_tax::context::StampTaxDocumentCode,
+    stated_amount: Option<u64>,
+) -> Result<(), JLawError> {
+    if !flag.allowed_document_codes().contains(&document_code) {
+        return Err(InputError::InvalidStampTaxInput {
+            field: "flags".into(),
+            reason: format!("{flag} は {document_code} には指定できません"),
+        }
+        .into());
+    }
+
+    if flag.requires_stated_amount() && stated_amount.is_none() {
+        return Err(InputError::InvalidStampTaxInput {
+            field: "stated_amount".into(),
+            reason: format!("{flag} を指定する場合は記載金額が必要です"),
+        }
+        .into());
+    }
+
+    Ok(())
+}
+
+fn resolve_special_rule(
+    ctx: &StampTaxContext,
+    document: &StampTaxDocumentParams,
+    rule: &StampTaxSpecialRule,
+) -> Result<ResolvedTaxRule, JLawError> {
+    if let Some(tax_amount) = rule.tax_amount {
+        let label = rule
+            .rule_label
+            .as_ref()
+            .cloned()
+            .unwrap_or_else(|| rule.label.clone());
+        return Ok(ResolvedTaxRule {
+            tax_amount,
+            rule_label: label,
+        });
+    }
+
+    if !rule.brackets.is_empty() || rule.no_amount_tax_amount.is_some() {
+        return resolve_amount_table(
+            ctx.stated_amount,
+            &rule.brackets,
+            rule.no_amount_tax_amount,
+            rule.no_amount_rule_label.as_deref(),
+            document,
+        );
+    }
+
+    Err(CalculationError::PolicyNotApplicable {
+        reason: format!("特例ルールの税額定義が不正です: {}", rule.code),
+    }
+    .into())
+}
+
+fn resolve_base_rule(
+    ctx: &StampTaxContext,
+    document: &StampTaxDocumentParams,
+) -> Result<ResolvedTaxRule, JLawError> {
+    match document.charge_mode {
+        StampTaxChargeMode::AmountBrackets => resolve_amount_table(
+            ctx.stated_amount,
+            &document.brackets,
+            document.no_amount_tax_amount,
+            document.no_amount_rule_label.as_deref(),
+            document,
+        ),
+        StampTaxChargeMode::FixedPerDocument | StampTaxChargeMode::FixedPerYear => {
+            let tax_amount =
+                document
+                    .base_tax_amount
+                    .ok_or_else(|| CalculationError::PolicyNotApplicable {
+                        reason: format!("固定税額が未設定です: {}", document.code),
+                    })?;
+            Ok(ResolvedTaxRule {
+                tax_amount,
+                rule_label: document.base_rule_label.clone(),
+            })
+        }
+    }
+}
+
+fn resolve_amount_table(
+    stated_amount: Option<u64>,
+    brackets: &[StampTaxBracket],
+    no_amount_tax_amount: Option<u64>,
+    no_amount_rule_label: Option<&str>,
+    document: &StampTaxDocumentParams,
+) -> Result<ResolvedTaxRule, JLawError> {
+    match stated_amount {
+        Some(amount) => {
+            let bracket = brackets
+                .iter()
+                .find(|bracket| bracket.matches(amount))
+                .ok_or_else(|| CalculationError::PolicyNotApplicable {
+                    reason: format!(
+                        "{} の記載金額 {}円 に対応する税額区分が見つかりません",
+                        document.code, amount
+                    ),
+                })?;
+            Ok(ResolvedTaxRule {
+                tax_amount: bracket.tax_amount,
+                rule_label: bracket.label.clone(),
+            })
+        }
+        None => {
+            let tax_amount =
+                no_amount_tax_amount.ok_or_else(|| InputError::InvalidStampTaxInput {
+                    field: "stated_amount".into(),
+                    reason: format!("{} には記載金額の指定が必要です", document.code),
+                })?;
+            let label = no_amount_rule_label
+                .unwrap_or("記載金額の記載のないもの")
+                .to_string();
+            Ok(ResolvedTaxRule {
+                tax_amount,
+                rule_label: label,
+            })
+        }
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use std::collections::{BTreeMap, HashSet};
+
+    use super::*;
+    use crate::domains::stamp_tax::context::StampTaxDocumentCode;
+    use crate::domains::stamp_tax::params::{StampTaxCitation, StampTaxSpecialRule};
+    use crate::domains::stamp_tax::policy::StandardNtaPolicy;
+    use crate::types::date::LegalDate;
+
+    fn amount_document() -> StampTaxDocumentParams {
+        StampTaxDocumentParams {
+            code: StampTaxDocumentCode::Article17SalesReceipt,
+            label: "売上代金受取書".into(),
+            citation: StampTaxCitation {
+                law_name: "印紙税法".into(),
+                article: "別表第一 第17号文書".into(),
+            },
+            charge_mode: StampTaxChargeMode::AmountBrackets,
+            amount_usage: StampTaxAmountUsage::Optional,
+            base_rule_label: "通常".into(),
+            base_tax_amount: None,
+            brackets: vec![StampTaxBracket {
+                label: "100万円以下のもの".into(),
+                amount_from: 50_000,
+                amount_to_inclusive: Some(1_000_000),
+                tax_amount: 200,
+            }],
+            no_amount_tax_amount: Some(200),
+            no_amount_rule_label: Some("受取金額の記載のないもの".into()),
+            special_rules: vec![StampTaxSpecialRule {
+                code: "article17_non_business_exempt".into(),
+                label: "非課税".into(),
+                priority: 1,
+                effective_from: None,
+                effective_until: None,
+                required_flags: vec![StampTaxFlag::Article17NonBusinessExempt],
+                tax_amount: Some(0),
+                rule_label: Some("営業に関しないもの".into()),
+                brackets: vec![],
+                no_amount_tax_amount: None,
+                no_amount_rule_label: None,
+            }],
+        }
+    }
+
+    #[test]
+    fn calculates_base_amount_rule() {
+        let mut documents = BTreeMap::new();
+        documents.insert(
+            StampTaxDocumentCode::Article17SalesReceipt,
+            amount_document(),
+        );
+        let params = StampTaxParams { documents };
+        let ctx = StampTaxContext {
+            document_code: StampTaxDocumentCode::Article17SalesReceipt,
+            stated_amount: Some(60_000),
+            target_date: LegalDate::new(2024, 8, 1),
+            flags: HashSet::new(),
+            policy: Box::new(StandardNtaPolicy),
+        };
+
+        let result = calculate_stamp_tax(&ctx, &params).unwrap();
+        assert_eq!(result.tax_amount.as_yen(), 200);
+        assert_eq!(result.rule_label, "100万円以下のもの");
+    }
+
+    #[test]
+    fn applies_special_rule() {
+        let mut documents = BTreeMap::new();
+        documents.insert(
+            StampTaxDocumentCode::Article17SalesReceipt,
+            amount_document(),
+        );
+        let params = StampTaxParams { documents };
+        let mut flags = HashSet::new();
+        flags.insert(StampTaxFlag::Article17NonBusinessExempt);
+        let ctx = StampTaxContext {
+            document_code: StampTaxDocumentCode::Article17SalesReceipt,
+            stated_amount: Some(60_000),
+            target_date: LegalDate::new(2024, 8, 1),
+            flags,
+            policy: Box::new(StandardNtaPolicy),
+        };
+
+        let result = calculate_stamp_tax(&ctx, &params).unwrap();
+        assert_eq!(result.tax_amount.as_yen(), 0);
+        assert_eq!(
+            result.applied_special_rule.as_deref(),
+            Some("article17_non_business_exempt")
+        );
+    }
+}