zanewalker/niritings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

(Init): Added shit

Browse Source
This commit is contained in:
Zane Walker
2026-05-29 00:41:12 +00:00
commit 72005fd71d
52 changed files with 12875 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

384
tests/test_window_effects.py Normal file
View File

@@ -0,0 +1,384 @@
"""Tests for global window effect rule helpers."""
from __future__ import annotations
import unittest
from nirimod.kdl_parser import KdlNode, parse_kdl, write_kdl
from nirimod.window_effects import (
blur_effects_enabled,
focused_window_blur_enabled,
get_global_draw_border_with_background,
get_global_corner_radius,
get_global_window_opacity,
global_window_blur_enabled,
global_window_xray_enabled,
set_focused_window_blur,
set_global_draw_border_with_background,
set_global_corner_radius,
set_global_window_blur,
set_global_window_opacity,
set_global_window_xray,
set_blur_effects_enabled,
)
class TestGlobalWindowEffects(unittest.TestCase):
def test_blur_effects_are_enabled_without_top_level_off(self):
nodes = parse_kdl(
"""
blur {
passes 3
offset 3
}
"""
)
self.assertTrue(blur_effects_enabled(nodes))
def test_disabling_blur_effects_writes_top_level_off(self):
nodes: list[KdlNode] = []
set_blur_effects_enabled(nodes, False)
out = write_kdl(nodes)
self.assertIn("blur", out)
self.assertIn("off", out)
self.assertNotIn("off true", out)
self.assertFalse(blur_effects_enabled(nodes))
def test_disabling_blur_effects_preserves_quality_settings(self):
nodes = parse_kdl(
"""
blur {
passes 3
offset 3
noise 0.02
saturation 1.5
}
"""
)
set_blur_effects_enabled(nodes, False)
out = write_kdl(nodes)
self.assertIn("off", out)
self.assertIn("passes 3", out)
self.assertIn("offset 3", out)
self.assertIn("noise 0.02", out)
self.assertIn("saturation 1.5", out)
self.assertNotIn("off true", out)
def test_enabling_blur_effects_removes_only_off(self):
nodes = parse_kdl(
"""
blur {
off
passes 3
offset 3
}
"""
)
set_blur_effects_enabled(nodes, True)
out = write_kdl(nodes)
blur = parse_kdl(out)[0]
self.assertIsNone(blur.get_child("off"))
self.assertIn("passes 3", out)
self.assertIn("offset 3", out)
self.assertTrue(blur_effects_enabled(nodes))
def test_enabling_blur_effects_sets_visible_default_opacity_when_unset(self):
nodes = parse_kdl(
"""
blur {
off
passes 3
}
"""
)
set_blur_effects_enabled(nodes, True)
out = write_kdl(nodes)
self.assertEqual(get_global_window_opacity(nodes), 0.9)
self.assertIn("opacity 0.9", out)
def test_enabling_blur_effects_preserves_existing_opacity(self):
nodes = parse_kdl(
"""
blur {
off
passes 3
}
window-rule {
opacity 0.75
}
"""
)
set_blur_effects_enabled(nodes, True)
self.assertEqual(get_global_window_opacity(nodes), 0.75)
self.assertIn("opacity 0.75", write_kdl(nodes))
def test_enabling_blur_creates_matchless_window_rule(self):
nodes: list[KdlNode] = []
set_global_window_blur(nodes, True)
out = write_kdl(nodes)
self.assertIn("window-rule", out)
self.assertIn("background-effect", out)
self.assertIn("blur true", out)
self.assertNotIn("draw-border-with-background", out)
self.assertTrue(global_window_blur_enabled(nodes))
def test_enabling_blur_sets_visible_default_opacity_when_unset(self):
nodes: list[KdlNode] = []
set_global_window_blur(nodes, True)
self.assertEqual(get_global_window_opacity(nodes), 0.9)
self.assertIn("opacity 0.9", write_kdl(nodes))
def test_enabling_blur_preserves_existing_opacity(self):
nodes = parse_kdl(
"""
window-rule {
opacity 0.75
}
"""
)
set_global_window_blur(nodes, True)
self.assertEqual(get_global_window_opacity(nodes), 0.75)
self.assertIn("opacity 0.75", write_kdl(nodes))
def test_disabling_blur_preserves_other_window_effect_settings(self):
nodes = parse_kdl(
"""
window-rule {
geometry-corner-radius 16
draw-border-with-background false
background-effect {
blur true
xray false
}
}
"""
)
set_global_window_blur(nodes, False)
rule = nodes[0]
self.assertEqual(rule.child_arg("geometry-corner-radius"), 16)
self.assertIsNotNone(rule.get_child("draw-border-with-background"))
self.assertIsNotNone(rule.get_child("background-effect"))
self.assertIsNone(rule.get_child("background-effect").get_child("blur"))
self.assertIsNotNone(rule.get_child("background-effect").get_child("xray"))
self.assertFalse(global_window_blur_enabled(nodes))
def test_disabling_blur_resets_window_opacity(self):
nodes = parse_kdl(
"""
window-rule {
opacity 0.95
background-effect {
blur true
xray false
}
}
"""
)
set_global_window_blur(nodes, False)
rule = nodes[0]
self.assertEqual(get_global_window_opacity(nodes), 1.0)
self.assertIsNone(rule.get_child("opacity"))
self.assertIsNone(rule.get_child("background-effect").get_child("blur"))
self.assertIsNotNone(rule.get_child("background-effect").get_child("xray"))
def test_disabling_blur_effects_clears_forced_blur_and_opacity(self):
nodes = parse_kdl(
"""
blur {
passes 3
}
window-rule {
opacity 0.9
background-effect {
blur true
xray false
}
}
window-rule {
match is-focused=true
background-effect {
blur true
}
}
"""
)
set_blur_effects_enabled(nodes, False)
out = write_kdl(nodes)
self.assertIn("off", out)
self.assertFalse(blur_effects_enabled(nodes))
self.assertFalse(global_window_blur_enabled(nodes))
self.assertFalse(focused_window_blur_enabled(nodes))
self.assertEqual(get_global_window_opacity(nodes), 1.0)
self.assertNotIn("blur true", out)
self.assertNotIn("opacity 0.9", out)
def test_corner_radius_writes_clip_and_can_be_removed(self):
nodes: list[KdlNode] = []
set_global_corner_radius(nodes, 16)
self.assertEqual(get_global_corner_radius(nodes), 16)
out = write_kdl(nodes)
self.assertIn("geometry-corner-radius 16", out)
self.assertIn("clip-to-geometry true", out)
set_global_corner_radius(nodes, 0)
self.assertEqual(nodes, [])
def test_matched_rules_are_not_reused_as_global_effect_rules(self):
nodes = parse_kdl(
"""
window-rule {
match app-id="Alacritty"
background-effect {
blur true
}
}
"""
)
set_global_corner_radius(nodes, 12)
self.assertEqual(len([n for n in nodes if n.name == "window-rule"]), 2)
self.assertIsNone(nodes[0].get_child("geometry-corner-radius"))
self.assertEqual(get_global_corner_radius(nodes), 12)
def test_global_opacity_is_removed_when_opaque(self):
nodes: list[KdlNode] = []
set_global_window_opacity(nodes, 0.9)
self.assertEqual(get_global_window_opacity(nodes), 0.9)
self.assertIn("opacity 0.9", write_kdl(nodes))
set_global_window_opacity(nodes, 1.0)
self.assertEqual(nodes, [])
def test_draw_border_with_background_can_be_toggled(self):
nodes: list[KdlNode] = []
self.assertTrue(get_global_draw_border_with_background(nodes))
set_global_draw_border_with_background(nodes, False)
self.assertFalse(get_global_draw_border_with_background(nodes))
self.assertIn("draw-border-with-background false", write_kdl(nodes))
set_global_draw_border_with_background(nodes, True)
self.assertTrue(get_global_draw_border_with_background(nodes))
self.assertEqual(nodes, [])
def test_xray_false_is_written_with_blur(self):
nodes: list[KdlNode] = []
set_global_window_blur(nodes, True)
set_global_window_xray(nodes, False)
out = write_kdl(nodes)
self.assertIn("blur true", out)
self.assertIn("xray false", out)
self.assertFalse(global_window_xray_enabled(nodes))
def test_xray_toggle_does_not_enable_blur(self):
nodes: list[KdlNode] = []
set_global_window_xray(nodes, True)
out = write_kdl(nodes)
self.assertIn("xray true", out)
self.assertNotIn("blur true", out)
self.assertFalse(global_window_blur_enabled(nodes))
def test_generated_global_window_effect_rule_is_compact(self):
nodes: list[KdlNode] = []
set_global_corner_radius(nodes, 16)
set_global_draw_border_with_background(nodes, False)
set_global_window_blur(nodes, True)
set_global_window_xray(nodes, False)
set_global_window_opacity(nodes, 0.75)
self.assertEqual(
write_kdl(nodes).strip(),
"""window-rule {
geometry-corner-radius 16
clip-to-geometry true
draw-border-with-background false
opacity 0.75
background-effect {
blur true
xray false
}
}""",
)
def test_focused_blur_rule_does_not_duplicate_global_effect_settings(self):
nodes: list[KdlNode] = []
set_global_window_blur(nodes, True)
set_global_window_xray(nodes, False)
set_global_window_opacity(nodes, 0.75)
set_focused_window_blur(nodes, True)
out = write_kdl(nodes)
self.assertIn("match is-focused=true", out)
self.assertEqual(out.count("opacity 0.75"), 1)
self.assertEqual(out.count("blur true"), 2)
self.assertEqual(out.count("xray false"), 1)
self.assertTrue(focused_window_blur_enabled(nodes))
def test_disabling_focused_blur_preserves_other_focused_rule_settings(self):
nodes = parse_kdl(
"""
window-rule {
match is-focused=true
block-out-from "screen-capture"
draw-border-with-background false
opacity 0.75
background-effect {
blur true
xray false
}
}
"""
)
set_focused_window_blur(nodes, False)
out = write_kdl(nodes)
self.assertIn('block-out-from "screen-capture"', out)
self.assertIn("draw-border-with-background false", out)
self.assertIn("opacity 0.75", out)
self.assertNotIn("blur true", out)
self.assertIn("xray false", out)
self.assertFalse(focused_window_blur_enabled(nodes))
if __name__ == "__main__":
unittest.main()