From e45327500d7a0cb43f288ca981be5516b0245e06 Mon Sep 17 00:00:00 2001
From: Yves Chevallier <yves.chevallier@heig-vd.ch>
Date: Tue, 8 Nov 2022 22:08:42 +0100
Subject: [PATCH] Fix filters args + Add tests for filters

---
 baygon/executable.py                |  1 +
 baygon/filters.py                   | 15 ++++++---
 baygon/suite.py                     |  3 +-
 tests/executable/test_executable.py |  2 +-
 tests/test_filters.py               | 51 +++++++++++++++++++++++++++++
 5 files changed, 65 insertions(+), 7 deletions(-)
 create mode 100644 tests/test_filters.py

diff --git a/baygon/executable.py b/baygon/executable.py
index 678fc7c..d34a75b 100644
--- a/baygon/executable.py
+++ b/baygon/executable.py
@@ -6,6 +6,7 @@
 import typing
 from collections import namedtuple
 from pathlib import Path
+
 from .error import InvalidExecutableError
 
 Outputs = namedtuple('Outputs', ['exit_status', 'stdout', 'stderr'])
diff --git a/baygon/filters.py b/baygon/filters.py
index b1b085e..4e085e3 100644
--- a/baygon/filters.py
+++ b/baygon/filters.py
@@ -5,6 +5,7 @@
 import re
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
+
 from .error import InvalidFilterError
 
 
@@ -15,11 +16,11 @@ def filter(self, value: str) -> str:
         """ Return True if the value matches the filter. """
         return value
 
-    def __init__(self, name: str = None):
-        self.name = name
+    def __init__(self, *args, **kwargs):
+        ...
 
     def __repr__(self):
-        return f'{self.__class__.__name__}<{self.name}>'
+        return f'{self.__class__.__name__}'
 
     def __call__(self, value: str) -> str:
         return self.filter(value)
@@ -133,8 +134,12 @@ def _parse_filter(self, filters):
         if isinstance(filters, Filters):
             return filters._filters
         if isinstance(filters, dict):
-            return [filter_map[name](args)
-                    for name, args in filters.items()]
+            instances = []
+            for name, args in filters.items():
+                if not isinstance(args, list):
+                    args = [args]
+                instances.append(filter_map[name](*args))
+            return instances
 
         raise InvalidFilterError(f'Invalid type for filters: {type(filters)}')
 
diff --git a/baygon/suite.py b/baygon/suite.py
index 8b0366c..c55ea3a 100644
--- a/baygon/suite.py
+++ b/baygon/suite.py
@@ -1,10 +1,11 @@
 """ Test suite. """
 import json
 from pathlib import Path
-from .error import InvalidExecutableError, ConfigError
+
 import yaml
 
 from . import error
+from .error import ConfigError, InvalidExecutableError
 from .executable import Executable
 from .filters import Filters
 from .id import Id
diff --git a/tests/executable/test_executable.py b/tests/executable/test_executable.py
index 4d319a9..e4669c9 100644
--- a/tests/executable/test_executable.py
+++ b/tests/executable/test_executable.py
@@ -3,8 +3,8 @@
 from unittest import TestCase
 
 from baygon import Executable
-from baygon.str import GreppableString
 from baygon.error import InvalidExecutableError
+from baygon.str import GreppableString
 
 dir_path = Path(__file__).resolve(strict=True).parent
 
diff --git a/tests/test_filters.py b/tests/test_filters.py
new file mode 100644
index 0000000..b4a7afe
--- /dev/null
+++ b/tests/test_filters.py
@@ -0,0 +1,51 @@
+""" Test filters. """
+from unittest import TestCase
+
+from baygon.filters import (
+    FilterIgnoreSpaces,
+    FilterLowercase,
+    FilterNone,
+    FilterRegex,
+    FilterReplace,
+    Filters,
+    FilterTrim,
+    FilterUppercase,
+)
+
+
+class TestFilters(TestCase):
+    def test_filter_uppercase(self):
+        f = FilterUppercase()
+        self.assertEqual(f('hello'), 'HELLO')
+
+    def test_filter_lowercase(self):
+        f = FilterLowercase()
+        self.assertEqual(f('HELLO'), 'hello')
+
+    def test_filter_trim(self):
+        f = FilterTrim()
+        self.assertEqual(f(' hello   '), 'hello')
+
+    def test_filter_none(self):
+        f = FilterNone()
+        self.assertEqual(f(' hello   '), ' hello   ')
+
+    def test_filter_replace(self):
+        f = FilterReplace('hello', 'bye')
+        self.assertEqual(f('hello world'), 'bye world')
+
+    def test_filter_regex(self):
+        f = FilterRegex(r'h[el]+o', 'bye')
+        self.assertEqual(f('hello world'), 'bye world')
+
+    def test_filter_ignore_spaces(self):
+        f = FilterIgnoreSpaces()
+        self.assertEqual(f('hello   world'), 'helloworld')
+
+    def test_filter_multiple(self):
+        f = Filters({
+            'ignorespaces': True,
+            'uppercase': True,
+            'replace': ['L', 'Z']
+        })
+        self.assertEqual(f('hello   world'), 'HEZZOWORZD')