From b9d37e023b4ac09ed057fce428c11fc15ee30365 Mon Sep 17 00:00:00 2001
From: Christian Ledermann <christian.ledermann@gmail.com>
Date: Sat, 9 Nov 2024 13:23:26 +0000
Subject: [PATCH] Add hypothesis test for styles and refactor StyleUrl class

---
 docs/working_with_kml.rst      |   9 +-
 fastkml/styles.py              |  20 +--
 tests/hypothesis/common.py     |   6 +
 tests/hypothesis/strategies.py |  11 ++
 tests/hypothesis/style_test.py | 267 +++++++++++++++++++++++++++++++++
 tests/repr_eq_test.py          |  14 --
 tests/styles_test.py           |  15 +-
 7 files changed, 302 insertions(+), 40 deletions(-)
 create mode 100644 tests/hypothesis/style_test.py

diff --git a/docs/working_with_kml.rst b/docs/working_with_kml.rst
index 8cda819a..ab630a61 100644
--- a/docs/working_with_kml.rst
+++ b/docs/working_with_kml.rst
@@ -164,6 +164,8 @@ Now we can create a new KML object and confirm that the new element is parsed co
 
 To be able to open the KML file in Google Earth Pro, we need to transform the
 CascadingStyle element into a supported Style element.
+To achieve this we copy the styles into the document styles and adjust their id
+to match the id of the CascadingStyle.
 
 .. code-block:: pycon
 
@@ -173,6 +175,11 @@ CascadingStyle element into a supported Style element.
     ...     kml_style.id = cascading_style.id
     ...     document.styles.append(kml_style)
     ...
+
+Now we can remove the CascadingStyle from the document and have a look at the result.
+
+.. code-block:: pycon
+
     >>> document.gx_cascading_style = []
     >>> print(document.to_string(prettyprint=True))
     <kml:Document xmlns:kml="http://www.opengis.net/kml/2.2">
@@ -222,7 +229,7 @@ CascadingStyle element into a supported Style element.
           <kml:color>80000000</kml:color>
         </kml:PolyStyle>
       </kml:Style>
-      <kml:Placemark id="04AFE6060F147CE66FBD">
+      <kml:Placemark id="04SAFE6060F147CE66FBD">
         <kml:name>Ort1</kml:name>
         <kml:LookAt>
           <kml:longitude>10.06256752902339</kml:longitude>
diff --git a/fastkml/styles.py b/fastkml/styles.py
index c70de2c7..ebd9a1ff 100644
--- a/fastkml/styles.py
+++ b/fastkml/styles.py
@@ -62,7 +62,7 @@
 logger = logging.getLogger(__name__)
 
 
-class StyleUrl(_BaseObject):
+class StyleUrl(_XMLObject):
     """
     URL of a <Style> or <StyleMap> defined in a Document.
 
@@ -73,14 +73,14 @@ class StyleUrl(_BaseObject):
     https://developers.google.com/kml/documentation/kmlreference#styleurl
     """
 
+    _default_nsid = config.KML
+
     url: Optional[str]
 
     def __init__(
         self,
         ns: Optional[str] = None,
         name_spaces: Optional[Dict[str, str]] = None,
-        id: Optional[str] = None,
-        target_id: Optional[str] = None,
         url: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
@@ -93,10 +93,6 @@ def __init__(
             The namespace of the Style object.
         name_spaces : dict, optional
             A dictionary of namespace prefixes and their corresponding URIs.
-        id : str, optional
-            The ID of the Style object.
-        target_id : str, optional
-            The ID of the target object that this Style object applies to.
         url : str, optional
             The URL of the Style object.
         **kwargs : Any
@@ -110,8 +106,6 @@ def __init__(
         super().__init__(
             ns=ns,
             name_spaces=name_spaces,
-            id=id,
-            target_id=target_id,
             **kwargs,
         )
         self.url = url
@@ -122,8 +116,6 @@ def __repr__(self) -> str:
             f"{self.__class__.__module__}.{self.__class__.__name__}("
             f"ns={self.ns!r}, "
             f"name_spaces={self.name_spaces!r}, "
-            f"id={self.id!r}, "
-            f"target_id={self.target_id!r}, "
             f"url={self.url!r}, "
             f"**{self._get_splat()!r},"
             ")"
@@ -352,10 +344,10 @@ def __bool__(self) -> bool:
 
         Returns
         -------
-            bool: True if both x and y are not None, False otherwise.
+            bool: True.
 
         """
-        return all((self.x is not None, self.y is not None))
+        return True
 
     @classmethod
     def get_tag_name(cls) -> str:
@@ -982,7 +974,7 @@ def __init__(
         )
         self.bg_color = bg_color
         self.text_color = text_color
-        self.text = text
+        self.text = text.strip() or None if text else None
         self.display_mode = display_mode
 
     def __repr__(self) -> str:
diff --git a/tests/hypothesis/common.py b/tests/hypothesis/common.py
index 843a78cc..6d09ba40 100644
--- a/tests/hypothesis/common.py
+++ b/tests/hypothesis/common.py
@@ -32,9 +32,12 @@
 import fastkml
 from fastkml.base import _XMLObject
 from fastkml.enums import AltitudeMode
+from fastkml.enums import ColorMode
 from fastkml.enums import DataType
 from fastkml.enums import DateTimeResolution
+from fastkml.enums import DisplayMode
 from fastkml.enums import RefreshMode
+from fastkml.enums import Units
 from fastkml.enums import Verbosity
 from fastkml.enums import ViewRefreshMode
 from fastkml.gx import Angle
@@ -61,6 +64,9 @@
     "datetime": datetime,
     "DateTimeResolution": DateTimeResolution,
     "DataType": DataType,
+    "Units": Units,
+    "ColorMode": ColorMode,
+    "DisplayMode": DisplayMode,
     "tzutc": tzutc,
     "tzfile": tzfile,
 }
diff --git a/tests/hypothesis/strategies.py b/tests/hypothesis/strategies.py
index 83f8f3ae..3190d6b2 100644
--- a/tests/hypothesis/strategies.py
+++ b/tests/hypothesis/strategies.py
@@ -92,3 +92,14 @@ def query_strings(draw: st.DrawFn) -> str:
         ),
     )
     return urlencode(params)
+
+
+@st.composite
+def kml_colors(draw: st.DrawFn) -> str:
+    return draw(
+        st.text(
+            alphabet=string.hexdigits,
+            min_size=8,
+            max_size=8,
+        ),
+    )
diff --git a/tests/hypothesis/style_test.py b/tests/hypothesis/style_test.py
new file mode 100644
index 00000000..95892672
--- /dev/null
+++ b/tests/hypothesis/style_test.py
@@ -0,0 +1,267 @@
+# Copyright (C) 2024  Christian Ledermann
+#
+# This library is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation; either version 2.1 of the License, or (at your option)
+# any later version.
+#
+# This library is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this library; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+"""Property-based tests for the views module."""
+
+import typing
+
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.provisional import urls
+
+import fastkml
+import fastkml.enums
+import fastkml.links
+import fastkml.styles
+from tests.base import Lxml
+from tests.hypothesis.common import assert_repr_roundtrip
+from tests.hypothesis.common import assert_str_roundtrip
+from tests.hypothesis.common import assert_str_roundtrip_terse
+from tests.hypothesis.common import assert_str_roundtrip_verbose
+from tests.hypothesis.strategies import kml_colors
+from tests.hypothesis.strategies import nc_name
+from tests.hypothesis.strategies import xml_text
+
+
+class TestLxml(Lxml):
+    @given(
+        url=st.one_of(st.none(), urls()),
+    )
+    def test_fuzz_style_url(
+        self,
+        url: typing.Optional[str],
+    ) -> None:
+        style_url = fastkml.StyleUrl(
+            url=url,
+        )
+
+        assert_repr_roundtrip(style_url)
+        assert_str_roundtrip(style_url)
+        assert_str_roundtrip_terse(style_url)
+        assert_str_roundtrip_verbose(style_url)
+
+    @given(
+        x=st.one_of(st.none(), st.floats(allow_nan=False, allow_infinity=False)),
+        y=st.one_of(st.none(), st.floats(allow_nan=False, allow_infinity=False)),
+        xunits=st.one_of(st.none(), st.sampled_from(fastkml.enums.Units)),
+        yunits=st.one_of(st.none(), st.sampled_from(fastkml.enums.Units)),
+    )
+    def test_fuzz_hot_spot(
+        self,
+        x: typing.Optional[float],
+        y: typing.Optional[float],
+        xunits: typing.Optional[fastkml.enums.Units],
+        yunits: typing.Optional[fastkml.enums.Units],
+    ) -> None:
+        hot_spot = fastkml.styles.HotSpot(
+            x=x,
+            y=y,
+            xunits=xunits,
+            yunits=yunits,
+        )
+
+        assert_repr_roundtrip(hot_spot)
+        assert_str_roundtrip(hot_spot)
+        assert_str_roundtrip_terse(hot_spot)
+        assert_str_roundtrip_verbose(hot_spot)
+
+    @given(
+        id=st.one_of(st.none(), nc_name()),
+        target_id=st.one_of(st.none(), nc_name()),
+        color=st.one_of(st.none(), kml_colors()),
+        color_mode=st.one_of(st.none(), st.sampled_from(fastkml.enums.ColorMode)),
+        scale=st.one_of(st.none(), st.floats(allow_nan=False, allow_infinity=False)),
+        heading=st.one_of(
+            st.none(),
+            st.floats(
+                allow_nan=False,
+                allow_infinity=False,
+                min_value=0,
+                max_value=360,
+            ),
+        ),
+        icon=st.one_of(
+            st.none(),
+            st.builds(
+                fastkml.links.Icon,
+                href=urls(),
+            ),
+        ),
+        hot_spot=st.one_of(
+            st.none(),
+            st.builds(
+                fastkml.styles.HotSpot,
+                x=st.floats(allow_nan=False, allow_infinity=False).filter(
+                    lambda x: x != 0,
+                ),
+                xunits=st.one_of(st.none(), st.sampled_from(fastkml.enums.Units)),
+                y=st.floats(allow_nan=False, allow_infinity=False).filter(
+                    lambda x: x != 0,
+                ),
+                yunits=st.one_of(st.none(), st.sampled_from(fastkml.enums.Units)),
+            ),
+        ),
+    )
+    def test_fuzz_icon_style(
+        self,
+        id: typing.Optional[str],
+        target_id: typing.Optional[str],
+        color: typing.Optional[str],
+        color_mode: typing.Optional[fastkml.enums.ColorMode],
+        scale: typing.Optional[float],
+        heading: typing.Optional[float],
+        icon: typing.Optional[fastkml.Icon],
+        hot_spot: typing.Optional[fastkml.styles.HotSpot],
+    ) -> None:
+        icon_style = fastkml.IconStyle(
+            id=id,
+            target_id=target_id,
+            color=color,
+            color_mode=color_mode,
+            scale=scale,
+            heading=heading,
+            icon=icon,
+            hot_spot=hot_spot,
+        )
+
+        assert_repr_roundtrip(icon_style)
+        assert_str_roundtrip(icon_style)
+        assert_str_roundtrip_terse(icon_style)
+        # the IconStyle does only allow for simple Icons, thats why
+        # assert_str_roundtrip_verbose fails at this time
+
+    @given(
+        id=st.one_of(st.none(), nc_name()),
+        target_id=st.one_of(st.none(), nc_name()),
+        color=st.one_of(st.none(), kml_colors()),
+        color_mode=st.one_of(st.none(), st.sampled_from(fastkml.enums.ColorMode)),
+        width=st.one_of(
+            st.none(),
+            st.floats(allow_nan=False, allow_infinity=False, min_value=0),
+        ),
+    )
+    def test_fuzz_line_style(
+        self,
+        id: typing.Optional[str],
+        target_id: typing.Optional[str],
+        color: typing.Optional[str],
+        color_mode: typing.Optional[fastkml.enums.ColorMode],
+        width: typing.Optional[float],
+    ) -> None:
+        line_style = fastkml.LineStyle(
+            id=id,
+            target_id=target_id,
+            color=color,
+            color_mode=color_mode,
+            width=width,
+        )
+
+        assert_repr_roundtrip(line_style)
+        assert_str_roundtrip(line_style)
+        assert_str_roundtrip_terse(line_style)
+        assert_str_roundtrip_verbose(line_style)
+
+    @given(
+        id=st.one_of(st.none(), nc_name()),
+        target_id=st.one_of(st.none(), nc_name()),
+        color=st.one_of(st.none(), kml_colors()),
+        color_mode=st.one_of(st.none(), st.sampled_from(fastkml.enums.ColorMode)),
+        fill=st.one_of(st.none(), st.booleans()),
+        outline=st.one_of(st.none(), st.booleans()),
+    )
+    def test_fuzz_poly_style(
+        self,
+        id: typing.Optional[str],
+        target_id: typing.Optional[str],
+        color: typing.Optional[str],
+        color_mode: typing.Optional[fastkml.enums.ColorMode],
+        fill: typing.Optional[bool],
+        outline: typing.Optional[bool],
+    ) -> None:
+        poly_style = fastkml.PolyStyle(
+            id=id,
+            target_id=target_id,
+            color=color,
+            color_mode=color_mode,
+            fill=fill,
+            outline=outline,
+        )
+
+        assert_repr_roundtrip(poly_style)
+        assert_str_roundtrip(poly_style)
+        assert_str_roundtrip_terse(poly_style)
+        assert_str_roundtrip_verbose(poly_style)
+
+    @given(
+        id=st.one_of(st.none(), nc_name()),
+        target_id=st.one_of(st.none(), nc_name()),
+        color=st.one_of(st.none(), kml_colors()),
+        color_mode=st.one_of(st.none(), st.sampled_from(fastkml.enums.ColorMode)),
+        scale=st.one_of(
+            st.none(),
+            st.floats(allow_nan=False, allow_infinity=False, min_value=0),
+        ),
+    )
+    def test_fuzz_label_style(
+        self,
+        id: typing.Optional[str],
+        target_id: typing.Optional[str],
+        color: typing.Optional[str],
+        color_mode: typing.Optional[fastkml.enums.ColorMode],
+        scale: typing.Optional[float],
+    ) -> None:
+        label_style = fastkml.LabelStyle(
+            id=id,
+            target_id=target_id,
+            color=color,
+            color_mode=color_mode,
+            scale=scale,
+        )
+
+        assert_repr_roundtrip(label_style)
+        assert_str_roundtrip(label_style)
+        assert_str_roundtrip_terse(label_style)
+        assert_str_roundtrip_verbose(label_style)
+
+    @given(
+        id=st.one_of(st.none(), nc_name()),
+        target_id=st.one_of(st.none(), nc_name()),
+        bg_color=st.one_of(st.none(), kml_colors()),
+        text_color=st.one_of(st.none(), kml_colors()),
+        text=st.one_of(st.none(), xml_text()),
+        display_mode=st.one_of(st.none(), st.sampled_from(fastkml.enums.DisplayMode)),
+    )
+    def test_fuzz_balloon_style(
+        self,
+        id: typing.Optional[str],
+        target_id: typing.Optional[str],
+        bg_color: typing.Optional[str],
+        text_color: typing.Optional[str],
+        text: typing.Optional[str],
+        display_mode: typing.Optional[fastkml.enums.DisplayMode],
+    ) -> None:
+        balloon_style = fastkml.BalloonStyle(
+            id=id,
+            target_id=target_id,
+            bg_color=bg_color,
+            text_color=text_color,
+            text=text,
+            display_mode=display_mode,
+        )
+
+        assert_repr_roundtrip(balloon_style)
+        assert_str_roundtrip(balloon_style)
+        assert_str_roundtrip_terse(balloon_style)
+        assert_str_roundtrip_verbose(balloon_style)
diff --git a/tests/repr_eq_test.py b/tests/repr_eq_test.py
index 2ec4baf0..3f56a6db 100644
--- a/tests/repr_eq_test.py
+++ b/tests/repr_eq_test.py
@@ -274,8 +274,6 @@ class TestRepr(StdLibrary):
                                         "atom": "{http://www.w3.org/2005/Atom}",
                                         "gx": "{http://www.google.com/kml/ext/2.2}",
                                     },
-                                    id="",
-                                    target_id="",
                                     url="#style-002",
                                 ),
                             ),
@@ -296,8 +294,6 @@ class TestRepr(StdLibrary):
                                         "atom": "{http://www.w3.org/2005/Atom}",
                                         "gx": "{http://www.google.com/kml/ext/2.2}",
                                     },
-                                    id="",
-                                    target_id="",
                                     url="#style-001",
                                 ),
                             ),
@@ -400,8 +396,6 @@ class TestRepr(StdLibrary):
                                                 "atom": "{http://www.w3.org/2005/Atom}",
                                                 "gx": "{http://www.google.com/kml/ext/2.2}",
                                             },
-                                            id="",
-                                            target_id="",
                                             url="#khStyle712",
                                         ),
                                         styles=[],
@@ -458,8 +452,6 @@ class TestRepr(StdLibrary):
                                                 "atom": "{http://www.w3.org/2005/Atom}",
                                                 "gx": "{http://www.google.com/kml/ext/2.2}",
                                             },
-                                            id="",
-                                            target_id="",
                                             url="#khStyle887",
                                         ),
                                         styles=[],
@@ -556,8 +548,6 @@ class TestRepr(StdLibrary):
                                                 "atom": "{http://www.w3.org/2005/Atom}",
                                                 "gx": "{http://www.google.com/kml/ext/2.2}",
                                             },
-                                            id="",
-                                            target_id="",
                                             url="#khStyle887",
                                         ),
                                         styles=[],
@@ -654,8 +644,6 @@ class TestRepr(StdLibrary):
                                                 "atom": "{http://www.w3.org/2005/Atom}",
                                                 "gx": "{http://www.google.com/kml/ext/2.2}",
                                             },
-                                            id="",
-                                            target_id="",
                                             url="#khStyle887",
                                         ),
                                         styles=[],
@@ -897,8 +885,6 @@ class TestRepr(StdLibrary):
                                                 "atom": "{http://www.w3.org/2005/Atom}",
                                                 "gx": "{http://www.google.com/kml/ext/2.2}",
                                             },
-                                            id="",
-                                            target_id="",
                                             url="#khStyle887",
                                         ),
                                         styles=[],
diff --git a/tests/styles_test.py b/tests/styles_test.py
index e8c2e348..7677dcaa 100644
--- a/tests/styles_test.py
+++ b/tests/styles_test.py
@@ -15,6 +15,7 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 
 """Test the styles classes."""
+
 import pytest
 
 from fastkml import links
@@ -34,13 +35,11 @@ class TestStdLibrary(StdLibrary):
     """Test with the standard library."""
 
     def test_style_url(self) -> None:
-        url = styles.StyleUrl(id="id-0", url="#style-0", target_id="target-0")
+        url = styles.StyleUrl(url="#style-0")
 
         serialized = url.to_string()
 
         assert '<kml:styleUrl xmlns:kml="http://www.opengis.net/kml/2.2"' in serialized
-        assert 'id="id-0"' in serialized
-        assert 'targetId="target-0"' in serialized
         assert ">#style-0</kml:styleUrl>" in serialized
 
     def test_style_url_read(self) -> None:
@@ -49,9 +48,7 @@ def test_style_url_read(self) -> None:
             ' id="id-0" targetId="target-0">#style-0</kml:styleUrl>',
         )
 
-        assert url.id == "id-0"
         assert url.url == "#style-0"
-        assert url.target_id == "target-0"
 
     def test_icon_style(self) -> None:
         icons = styles.IconStyle(
@@ -455,7 +452,7 @@ def test_style_read(self) -> None:
         assert style.styles[4].outline == 1
 
     def test_stylemap(self) -> None:  # noqa: PLR0915
-        url = styles.StyleUrl(id="id-0", url="#style-0", target_id="target-0")
+        url = styles.StyleUrl(url="#style-0")
         icons = styles.IconStyle(
             id="id-i0",
             target_id="target-i0",
@@ -512,11 +509,9 @@ def test_stylemap(self) -> None:  # noqa: PLR0915
         serialized = sm.to_string()
 
         assert '<kml:StyleMap xmlns:kml="http://www.opengis.net/kml/2.2" ' in serialized
-        assert 'id="id-sm-0"' in serialized
-        assert 'targetId="target-sm-0"' in serialized
         assert "<kml:Pair>" in serialized
         assert "<kml:key>normal</kml:key>" in serialized
-        assert "<kml:styleUrl " in serialized
+        assert "<kml:styleUrl" in serialized
         assert "</kml:Pair>" in serialized
         assert "<kml:Pair>" in serialized
         assert "<kml:key>highlight</kml:key>" in serialized
@@ -609,8 +604,6 @@ def test_stylemap_read(self) -> None:
         assert sm.target_id == "target-sm-0"
         assert sm.normal.id == "id-0"
         assert sm.normal.target_id == "target-0"
-        assert sm.highlight.id == "id-u0"
-        assert sm.highlight.target_id == "target-u0"
 
     def test_style_map_none_case(self) -> None:
         sm = styles.StyleMap()