exdrf 0.0.1.dev0__py3-none-any.whl

exdrf_tests/test_label_dsl.py

@@ -0,0 +1,234 @@
+from datetime import datetime
+
+import pytest
+
+from exdrf.label_dsl import (
+    ParsedIdentifier,
+    ParsedLiteral,
+    ParsedOp,
+    evaluate,
+    generate_python_code,
+    generate_typescript_code,
+    get_used_fields,
+    parse_expr,
+)
+
+
+class DummyContext:
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+
+def test_parse_expr_concat():
+    expr = '(concat "Hello" "World")'
+    ast = parse_expr(expr)
+    # Check that the AST is a list starting with an operator
+    assert isinstance(ast, list)
+    op = ast[0]
+    assert isinstance(op, ParsedOp)
+    assert op.value == "concat"
+    # Remaining tokens should be literals
+    lit1 = ast[1]
+    lit2 = ast[2]
+    assert isinstance(lit1, ParsedLiteral)
+    assert lit1.value == "Hello"
+    assert isinstance(lit2, ParsedLiteral)
+    assert lit2.value == "World"
+
+
+def test_evaluate_concat_literals():
+    expr = '(concat "Hello" " " "World")'
+    ast = parse_expr(expr)
+    # All arguments are literals so context is not used (pass None)
+    result = evaluate(ast, None)
+    assert result == "Hello World"
+
+
+def test_evaluate_identifier_with_upper():
+    expr = "(upper name)"
+    ast = parse_expr(expr)
+    context = DummyContext(name="test")
+    result = evaluate(ast, context)
+    assert result == "TEST"
+
+
+def test_generate_python_code():
+    expr = '(concat "foo" "bar")'
+    ast = parse_expr(expr)
+    code = generate_python_code(ast)
+    # The generated code should join the literals with a Python plus operator
+    assert " + " in code
+    assert '"foo"' in code
+    assert '"bar"' in code
+
+
+def test_generate_typescript_code_with_identifier():
+    expr = '(concat "foo" bar)'
+    ast = parse_expr(expr)
+    ts_code = generate_typescript_code(ast)
+    assert '("foo" + record.bar)' == ts_code
+
+
+def test_get_used_fields():
+    expr = "(concat first_name last.name)"
+    ast = parse_expr(expr)
+    fields = get_used_fields(ast)
+    # The current implementation collects ParsedOp values, so it returns the
+    # operator.
+    # This test checks that behavior.
+    assert fields == ["first_name", "last.name"]
+
+
+def test_nested_expression_evaluate():
+    expr = "(concat (upper first_name) (lower last_name))"
+    ast = parse_expr(expr)
+    context = DummyContext(first_name="john", last_name="DOE")
+    result = evaluate(ast, context)
+    assert result == "JOHNdoe"
+
+
+def test_eq_same_value_same_class():
+    op1 = ParsedOp("test")
+    op2 = ParsedOp("test")
+    assert op1 == op2
+    lit1 = ParsedLiteral("hello")
+    lit2 = ParsedLiteral("hello")
+    assert lit1 == lit2
+
+
+def test_eq_same_value_different_subclasses():
+    # Even though they are different subclasses of Parsed,
+    # equality compares the 'value' attribute only.
+    op = ParsedOp("value")
+    lit = ParsedLiteral("value")
+    ident = ParsedIdentifier("value")
+    assert op == lit
+    assert op == ident
+    assert lit == ident
+
+
+def test_eq_with_string():
+    op = ParsedOp("example")
+    lit = ParsedLiteral("example")
+    ident = ParsedIdentifier("example")
+    assert op == "example"
+    assert lit == "example"
+    assert ident == "example"
+
+
+def test_eq_different_values():
+    op = ParsedOp("one")
+    lit = ParsedLiteral("two")
+    ident = ParsedIdentifier("three")
+    assert not (op == lit)
+    assert not (lit == ident)
+    assert not (op == ident)
+
+
+def test_eq_non_parsed_object():
+    op = ParsedOp("data")
+    # When comparing with an object that is not an instance of Parsed or str,
+    # equality should return False.
+    assert not (op == 123)
+    assert op is not None
+
+
+def test_if():
+    context = DummyContext(name="test")
+    expr = '(if name "Yes" "No")'
+    ast = parse_expr(expr)
+    result = evaluate(ast, context)
+    assert result == "Yes"
+
+    py_code = generate_python_code(ast)
+    assert '("Yes" if record.name else "No")' in py_code
+
+    ts_code = generate_typescript_code(ast)
+    assert '(record.name ? "Yes" : "No")' in ts_code
+
+
+def test_upper():
+    context = DummyContext(name="test")
+    expr = "(upper name)"
+    ast = parse_expr(expr)
+    result = evaluate(ast, context)
+    assert result == "TEST"
+
+    py_code = generate_python_code(ast)
+    assert "str(record.name).upper()" in py_code
+
+    ts_code = generate_typescript_code(ast)
+    assert "String(record.name).toUpperCase()" in ts_code
+
+
+def test_lower():
+    context = DummyContext(name="TEST")
+    expr = "(lower name)"
+    ast = parse_expr(expr)
+    result = evaluate(ast, context)
+    assert result == "test"
+
+    py_code = generate_python_code(ast)
+    assert "str(record.name).lower()" in py_code
+
+    ts_code = generate_typescript_code(ast)
+    assert "String(record.name).toLowerCase()" in ts_code
+
+
+def test_is_none():
+    context = DummyContext(name=None)
+    expr = '(is_none name "Yes" "No")'
+    ast = parse_expr(expr)
+    result = evaluate(ast, context)
+    assert result == "Yes"
+
+    py_code = generate_python_code(ast)
+    assert '("Yes" if record.name is None else "No")' in py_code
+
+    ts_code = generate_typescript_code(ast)
+    assert '(record.name == null || record.name == undefined) ? "Yes" : "No"' in ts_code
+
+    context = DummyContext(name="test")
+    expr = '(is_none name "Yes" "No")'
+    ast = parse_expr(expr)
+    result = evaluate(ast, context)
+    assert result == "No"
+
+
+def test_equals():
+    context = DummyContext(name="test")
+    expr = '(= name "test" "Yes" "No")'
+    ast = parse_expr(expr)
+    result = evaluate(ast, context)
+    assert result == "Yes"
+
+    py_code = generate_python_code(ast)
+    assert '("Yes" if record.name == "test" else "No")' in py_code
+
+    ts_code = generate_typescript_code(ast)
+    assert '((record.name == "test") ? "Yes" : "No")' in ts_code
+
+    context = DummyContext(name="not")
+    expr = '(= name "test" "Yes" "No")'
+    ast = parse_expr(expr)
+    result = evaluate(ast, context)
+    assert result == "No"
+
+
+def test_date_str():
+    context = DummyContext(date=datetime(2023, 10, 1))
+    expr = '(date_str date "%Y-%m-%d")'
+    ast = parse_expr(expr)
+    result = evaluate(ast, context)
+    assert result == "2023-10-01"
+
+    py_code = generate_python_code(ast)
+    assert 'record.date.strftime("%Y-%m-%d")' in py_code
+
+    ts_code = generate_typescript_code(ast)
+    assert 'record.date.strftime("%Y-%m-%d")' in ts_code
+
+
+if __name__ == "__main__":
+    pytest.main()

exdrf_tests/test_resource.py

@@ -0,0 +1,107 @@
+from unittest.mock import Mock
+
+import pytest
+
+from exdrf.resource import ExResource
+
+
+def test_exresource_initialization():
+    resource = ExResource(name="TestResource")
+    assert resource.name == "TestResource"
+    assert resource.fields == []
+    assert resource.categories == []
+    assert resource.description == ""
+    assert resource.src is None
+    assert resource.label_ast is None
+
+
+def test_exresource_repr():
+    resource = ExResource(name="TestResource")
+    assert repr(resource) == "<Resource TestResource (0 fields)>"
+
+
+def test_exresource_add_field():
+    mock_field = Mock()
+    mock_field.name = "test_field"
+    mock_field.type_name = "string"
+    mock_field.category = None
+
+    resource = ExResource(name="TestResource")
+    resource.add_field(mock_field)
+
+    assert len(resource.fields) == 1
+    assert resource.fields[0] == mock_field
+    assert mock_field.resource == resource
+
+
+def test_exresource_getitem_by_index():
+    mock_field = Mock()
+    mock_field.name = "test_field"
+    mock_field.type_name = "string"
+
+    resource = ExResource(name="TestResource")
+    resource.add_field(mock_field)
+
+    assert resource[0] == mock_field
+
+
+def test_exresource_getitem_by_name():
+    mock_field = Mock()
+    mock_field.name = "test_field"
+    mock_field.type_name = "string"
+
+    resource = ExResource(name="TestResource")
+    resource.add_field(mock_field)
+
+    assert resource["test_field"] == mock_field
+
+
+def test_exresource_getitem_keyerror():
+    resource = ExResource(name="TestResource")
+    with pytest.raises(KeyError):
+        _ = resource["nonexistent_field"]
+
+
+def test_exresource_pascal_case_name():
+    resource = ExResource(name="TestResource")
+    assert resource.pascal_case_name == "TestResource"
+
+
+def test_exresource_snake_case_name():
+    resource = ExResource(name="TestResource")
+    assert resource.snake_case_name == "test_resource"
+
+
+def test_exresource_snake_case_name_plural():
+    resource = ExResource(name="TestResource")
+    assert resource.snake_case_name_plural == "test_resources"
+
+
+def test_exresource_camel_case_name():
+    resource = ExResource(name="TestResource")
+    assert resource.camel_case_name == "testResource"
+
+
+def test_exresource_text_name():
+    resource = ExResource(name="TestResource")
+    assert resource.text_name == "Test resource"
+
+
+def test_exresource_doc_lines():
+    resource = ExResource(name="TestResource", description="This is a test resource.")
+    assert resource.doc_lines == ["This is a test resource."]
+
+
+def test_exresource_get_dependencies():
+    mock_field = Mock()
+    mock_field.is_ref_type = True
+    mock_field.ref = Mock()
+    mock_field.ref.name = "DependencyResource"
+    mock_field.extra_ref = Mock(return_value=[])
+
+    resource = ExResource(name="TestResource")
+    resource.add_field(mock_field)
+
+    dependencies = resource.get_dependencies()
+    assert len(dependencies) == 1
+    assert list(dependencies)[0].name == "DependencyResource"

exdrf_tests/test_utils.py

@@ -0,0 +1,43 @@
+from exdrf.utils import doc_lines
+
+
+def test_doc_lines_single_line():
+    text = "This is a single line of text."
+    expected = ["This is a single line of text."]
+    assert doc_lines(text) == expected
+
+
+def test_doc_lines_multiple_lines():
+    text = "This is the first line.\nThis is the second line."
+    expected = ["This is the first line.", "", "This is the second line."]
+    assert doc_lines(text) == expected
+
+
+def test_doc_lines_wrapping():
+    text = (
+        "This is a very long line of text that should be wrapped into "
+        "multiple lines because it exceeds the width limit."
+    )
+    expected = [
+        "This is a very long line of text that should be wrapped into multiple",
+        "lines because it exceeds the width limit.",
+    ]
+    assert doc_lines(text) == expected
+
+
+def test_doc_lines_empty_string():
+    text = ""
+    expected = []
+    assert doc_lines(text) == expected
+
+
+def test_doc_lines_with_leading_and_trailing_whitespace():
+    text = "   This line has leading and trailing spaces.   "
+    expected = ["This line has leading and trailing spaces."]
+    assert doc_lines(text) == expected
+
+
+def test_doc_lines_with_blank_lines():
+    text = "Line one.\n\nLine three."
+    expected = ["Line one.", "", "", "Line three."]
+    assert doc_lines(text) == expected

exdrf_tests/test_visitor.py

@@ -0,0 +1,31 @@
+from unittest.mock import MagicMock
+
+from exdrf.visitor import ExVisitor
+
+
+class TestExVisitor:
+    def test_visit_dataset(self):
+        visitor = ExVisitor()
+        mock_dataset = MagicMock()
+        result = visitor.visit_dataset(mock_dataset)
+        assert result is True
+
+    def test_visit_category(self):
+        visitor = ExVisitor()
+        name = "category_name"
+        level = 1
+        content = {"sub_category": {}, "resource": {}}
+        result = visitor.visit_category(name, level, content)
+        assert result is True
+
+    def test_visit_resource(self):
+        visitor = ExVisitor()
+        mock_resource = MagicMock()
+        result = visitor.visit_resource(mock_resource)
+        assert result is True
+
+    def test_visit_field(self):
+        visitor = ExVisitor()
+        mock_field = MagicMock()
+        result = visitor.visit_field(mock_field)
+        assert result is True