lint

tests/integration/test_chained_trainsformers_task.py

@@ -7,23 +7,42 @@
 from databuilder.models.table_metadata import TableMetadata
 from databuilder.models.table_owner import TableOwner
 from databuilder.task.task import DefaultTask
-from databuilder.transformer.base_transformer import ChainedTransformer, NoopTransformer, Transformer
+from databuilder.transformer.base_transformer import (
+    ChainedTransformer,
+    NoopTransformer,
+    Transformer,
+)
 
 from pyhocon import ConfigFactory, ConfigTree
 
 TEST_DATA = [
-    TableMetadata(database="db1", schema="schema1", name="table1", cluster="prod", description=""),
-    TableMetadata(database="db2", schema="schema2", name="table2", cluster="prod", description=""),
+    TableMetadata(
+        database="db1", schema="schema1", name="table1", cluster="prod", description=""
+    ),
+    TableMetadata(
+        database="db2", schema="schema2", name="table2", cluster="prod", description=""
+    ),
 ]
 
 EXPECTED_OWNERS = [
-    TableOwner(db_name="db1", cluster="prod", schema="schema1", table_name="table1", owners=["foo", "bar"]),
-    TableOwner(db_name="db2", cluster="prod", schema="schema2", table_name="table2", owners=["foo", "bar"]),
+    TableOwner(
+        db_name="db1",
+        cluster="prod",
+        schema="schema1",
+        table_name="table1",
+        owners=["foo", "bar"],
+    ),
+    TableOwner(
+        db_name="db2",
+        cluster="prod",
+        schema="schema2",
+        table_name="table2",
+        owners=["foo", "bar"],
+    ),
 ]
 
 
 class TestChainedTransformerTask(unittest.TestCase):
-
     def test_multi_yield_task(self) -> None:
         """ Test that MultiYieldTask is able to unpack a transformer which yields multiple nodes """
 
@@ -33,15 +52,16 @@ def test_multi_yield_task(self) -> None:
 
         self.assertEqual(repr(result), repr(expected))
 
-
     def test_multi_yield_chained_transformer(self) -> None:
         """
         Test that MultiYieldChainedTransformer is able handle both:
             - transformers which yield multiple nodes
             - transformers which transform single nodes
         """
 
-        transformer = ChainedTransformer([AddFakeOwnerTransformer(), NoopTransformer(), DuplicateTransformer()])
+        transformer = ChainedTransformer(
+            [AddFakeOwnerTransformer(), NoopTransformer(), DuplicateTransformer()]
+        )
 
         result = _run_transformer(transformer)
 
@@ -94,7 +114,6 @@ def transform(self, record: Any) -> Iterable[Any]:
         yield record
 
 
-
 class ListExtractor(Extractor):
     """ An extractor which yields a list of records """
 
@@ -121,12 +140,13 @@ def load(self, record: Any) -> None:
         self.loaded.append(record)
 
 
-
 def _run_transformer(transformer: Transformer) -> List[Any]:
     job_config = ConfigFactory.from_dict({"extractor.test.items": TEST_DATA})
 
     loader = ListLoader()
-    task = DefaultTask(extractor=ListExtractor(), transformer=transformer, loader=loader)
+    task = DefaultTask(
+        extractor=ListExtractor(), transformer=transformer, loader=loader
+    )
     job = DefaultJob(conf=job_config, task=task)
 
     job.launch()

tests/unit/transformer/test_chained_transformer.py

@@ -10,20 +10,21 @@
 
 
 class TestChainedTransformer(unittest.TestCase):
-
     def test_init_not_called(self) -> None:
 
         mock_transformer1 = MagicMock()
-        mock_transformer1.transform.return_value = 'foo'
+        mock_transformer1.transform.return_value = "foo"
         mock_transformer2 = MagicMock()
-        mock_transformer2.transform.return_value = 'bar'
-
-        chained_transformer = ChainedTransformer(transformers=[mock_transformer1, mock_transformer2])
+        mock_transformer2.transform.return_value = "bar"
+
+        chained_transformer = ChainedTransformer(
+            transformers=[mock_transformer1, mock_transformer2]
+        )
 
         config = ConfigFactory.from_dict({})
         chained_transformer.init(conf=config)
-        
-        next(chained_transformer.transform({'foo': 'bar'}))
+
+        next(chained_transformer.transform({"foo": "bar"}))
 
         mock_transformer1.init.assert_not_called()
         mock_transformer1.transform.assert_called_once()
@@ -33,19 +34,21 @@ def test_init_not_called(self) -> None:
     def test_init_called(self) -> None:
 
         mock_transformer1 = MagicMock()
-        mock_transformer1.get_scope.return_value = 'foo'
-        mock_transformer1.transform.return_value = 'foo'
+        mock_transformer1.get_scope.return_value = "foo"
+        mock_transformer1.transform.return_value = "foo"
         mock_transformer2 = MagicMock()
-        mock_transformer2.get_scope.return_value = 'bar'
-        mock_transformer2.transform.return_value = 'bar'
+        mock_transformer2.get_scope.return_value = "bar"
+        mock_transformer2.transform.return_value = "bar"
 
-        chained_transformer = ChainedTransformer(transformers=[mock_transformer1, mock_transformer2],
-                                                 is_init_transformers=True)
+        chained_transformer = ChainedTransformer(
+            transformers=[mock_transformer1, mock_transformer2],
+            is_init_transformers=True,
+        )
 
         config = ConfigFactory.from_dict({})
         chained_transformer.init(conf=config)
 
-        next(chained_transformer.transform({'foo': 'bar'}))
+        next(chained_transformer.transform({"foo": "bar"}))
 
         mock_transformer1.init.assert_called_once()
         mock_transformer1.transform.assert_called_once()
@@ -55,14 +58,16 @@ def test_init_called(self) -> None:
     def test_transformer_transforms(self) -> None:
 
         mock_transformer1 = MagicMock()
-        mock_transformer1.transform.side_effect = lambda s: s+'b'
+        mock_transformer1.transform.side_effect = lambda s: s + "b"
         mock_transformer2 = MagicMock()
-        mock_transformer2.transform.side_effect = lambda s: s+'c'
-
-        chained_transformer = ChainedTransformer(transformers=[mock_transformer1, mock_transformer2])
+        mock_transformer2.transform.side_effect = lambda s: s + "c"
+
+        chained_transformer = ChainedTransformer(
+            transformers=[mock_transformer1, mock_transformer2]
+        )
 
         config = ConfigFactory.from_dict({})
         chained_transformer.init(conf=config)
-        
-        result = next(chained_transformer.transform('a'))
-        self.assertEqual(result, 'abc')
+
+        result = next(chained_transformer.transform("a"))
+        self.assertEqual(result, "abc")