<gh_stars>1000+
import unittest

import dash.dash_table.Format as f
from dash.dash_table.Format import Format
import dash.dash_table.FormatTemplate as FormatTemplate


class FormatTest(unittest.TestCase):
    def validate_complex(self, res):
        self.assertEqual(res["locale"]["symbol"][0], "a")
        self.assertEqual(res["locale"]["symbol"][1], "bc")
        self.assertEqual(res["locale"]["decimal"], "x")
        self.assertEqual(res["locale"]["group"], "y")
        self.assertEqual(res["nully"], "N/A")
        self.assertEqual(res["prefix"], None)
        self.assertEqual(res["specifier"], ".^($010,.6s")

    def test_complex_and_valid_in_ctor(self):
        res = Format(
            align=f.Align.center,
            fill=".",
            group=f.Group.yes,
            padding=True,
            padding_width=10,
            precision=6,
            scheme="s",
            sign=f.Sign.parantheses,
            symbol=f.Symbol.yes,
            symbol_prefix="a",
            symbol_suffix="bc",
            decimal_delimiter="x",
            group_delimiter="y",
            groups=[2, 2, 2, 3],
            nully="N/A",
            si_prefix=f.Prefix.none,
        )

        self.validate_complex(res.to_plotly_json())

    def test_complex_and_valid_in_fluent(self):
        res = (
            Format()
            .align(f.Align.center)
            .fill(".")
            .group(f.Group.yes)
            .padding(True)
            .padding_width(10)
            .precision(6)
            .scheme("s")
            .sign(f.Sign.parantheses)
            .symbol(f.Symbol.yes)
            .symbol_prefix("a")
            .symbol_suffix("bc")
            .decimal_delimiter("x")
            .group_delimiter("y")
            .groups([2, 2, 2, 3])
            .nully("N/A")
            .si_prefix(f.Prefix.none)
        )

        self.validate_complex(res.to_plotly_json())

    def test_money_template(self):
        res = FormatTemplate.money(2).to_plotly_json()

        self.assertEqual(res["specifier"], "$,.2f")

    def test_percentage_template(self):
        res = FormatTemplate.percentage(1).to_plotly_json()

        self.assertEqual(res["specifier"], ".1%")

    def test_valid_align_named(self):
        Format().align(f.Align.center)

    def test_valid_align_string(self):
        Format().align("=")

    def test_invalid_align_string(self):
        self.assertRaises(TypeError, Format().align, "i")

    def test_invalid_align_type(self):
        self.assertRaises(TypeError, Format().align, 7)

    def test_valid_fill(self):
        Format().fill(".")

    def test_invalid_fill_length(self):
        self.assertRaises(ValueError, Format().fill, "invalid")

    def test_invalid_fill_type(self):
        self.assertRaises(TypeError, Format().fill, 7)

    def test_valid_group_bool(self):
        Format().group(True)

    def test_valid_group_string(self):
        Format().group(",")

    def test_valid_group_named(self):
        Format().group(f.Group.no)

    def test_invalid_group_type(self):
        self.assertRaises(TypeError, Format().group, 7)

    def test_invalid_group_string(self):
        self.assertRaises(TypeError, Format().group, "invalid")

    def test_valid_padding_bool(self):
        Format().padding(False)

    def test_valid_padding_string(self):
        Format().padding("0")

    def test_valid_padding_named(self):
        Format().padding(f.Padding.no)

    def test_invalid_padding_type(self):
        self.assertRaises(TypeError, Format().padding, 7)

    def test_invalid_padding_string(self):
        self.assertRaises(TypeError, Format().padding, "invalid")

    def test_valid_padding_width(self):
        Format().padding_width(10)

    def test_valid_padding_width_0(self):
        Format().padding_width(0)

    def test_invalid_padding_width_negative(self):
        self.assertRaises(ValueError, Format().padding_width, -10)

    def test_invalid_padding_width_type(self):
        self.assertRaises(TypeError, Format().padding_width, 7.7)

    def test_valid_precision(self):
        Format().precision(10)

    def test_valid_precision_0(self):
        Format().precision(0)

    def test_invalid_precision_negative(self):
        self.assertRaises(ValueError, Format().precision, -10)

    def test_invalid_precision_type(self):
        self.assertRaises(TypeError, Format().precision, 7.7)

    def test_valid_prefix_number(self):
        Format().si_prefix(10 ** -24)

    def test_valid_prefix_named(self):
        Format().si_prefix(f.Prefix.micro)

    def test_invalid_prefix_number(self):
        self.assertRaises(TypeError, Format().si_prefix, 10 ** -23)

    def test_invalid_prefix_type(self):
        self.assertRaises(TypeError, Format().si_prefix, "10**-23")

    def test_valid_scheme_string(self):
        Format().scheme("s")

    def test_valid_scheme_named(self):
        Format().scheme(f.Scheme.decimal)

    def test_invalid_scheme_string(self):
        self.assertRaises(TypeError, Format().scheme, "invalid")

    def test_invalid_scheme_type(self):
        self.assertRaises(TypeError, Format().scheme, 7)

    def test_valid_sign_string(self):
        Format().sign("+")

    def test_valid_sign_named(self):
        Format().sign(f.Sign.space)

    def test_invalid_sign_string(self):
        self.assertRaises(TypeError, Format().sign, "invalid")

    def test_invalid_sign_type(self):
        self.assertRaises(TypeError, Format().sign, 7)

    def test_valid_symbol_string(self):
        Format().symbol("$")

    def test_valid_symbol_named(self):
        Format().symbol(f.Symbol.hex)

    def test_invalid_symbol_string(self):
        self.assertRaises(TypeError, Format().symbol, "invalid")

    def test_invalid_symbol_type(self):
        self.assertRaises(TypeError, Format().symbol, 7)

    def test_valid_symbol_prefix(self):
        Format().symbol_prefix("abc+-")

    def test_invalid_symbol_prefix_type(self):
        self.assertRaises(TypeError, Format().symbol_prefix, 7)

    def test_valid_symbol_suffix(self):
        Format().symbol_suffix("abc+-")

    def test_invalid_symbol_suffix(self):
        self.assertRaises(TypeError, Format().symbol_suffix, 7)

    def test_valid_trim_boolean(self):
        Format().trim(False)

    def test_valid_trim_string(self):
        Format().trim("~")

    def test_valid_trim_named(self):
        Format().trim(f.Trim.yes)

    def test_invalid_trim_string(self):
        self.assertRaises(TypeError, Format().trim, "invalid")

    def test_invalid_trim_type(self):
        self.assertRaises(TypeError, Format().trim, 7)

    def test_valid_decimal_delimiter(self):
        Format().decimal_delimiter("x")

    def test_valid_decimal_delimiter_multi_char(self):
        self.assertRaises(ValueError, Format().decimal_delimiter, "xyz")

    def test_invalid_decimal_delimiter(self):
        self.assertRaises(TypeError, Format().decimal_delimiter, 7)

    def test_valid_group_delimitator(self):
        Format().group_delimiter("y")

    def test_valid_group_delimitator_multi_char(self):
        self.assertRaises(ValueError, Format().group_delimiter, "xyz")

    def test_invalid_group_delimiter(self):
        self.assertRaises(TypeError, Format().group_delimiter, 7)

    def test_valid_groups(self):
        Format().groups([3])

    def test_valid_groups_single(self):
        Format().groups(3)

    def test_valid_groups_multi(self):
        Format().groups([2, 2, 3])

    def test_invalid_groups_single_0(self):
        self.assertRaises(ValueError, Format().groups, 0)

    def test_invalid_groups_single_negative(self):
        self.assertRaises(ValueError, Format().groups, -7)

    def test_invalid_groups_single_type(self):
        self.assertRaises(TypeError, Format().groups, 7.7)

    def test_invalid_groups_empty(self):
        self.assertRaises(ValueError, Format().groups, [])

    def test_invalid_groups_nested_type(self):
        self.assertRaises(TypeError, Format().groups, [7.7, 7])

    def test_invalid_groups_nested_0(self):
        self.assertRaises(ValueError, Format().groups, [3, 3, 0])

    def test_invalid_groups_nested_negative(self):
        self.assertRaises(ValueError, Format().groups, [3, 3, -7])
