behave-data 0.1.2__tar.gz → 0.1.3__tar.gz

{behave_data-0.1.2 → behave_data-0.1.3}/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.3] - 2026-07-17
+
+### Added
+
+- 75 edge case unit tests covering hooks, secrets, examples, raw_table, yaml, types, diff, fixtures, loaders, config, and manager
+- 4 new E2E Behave integration features: fixtures_builders, secrets, typed_table_edge, dynamic_examples
+- 27 E2E scenarios with 64 steps testing all behave-data features in real Behave
+
+### Fixed
+
+- `tags.py` now strips `@` prefix from Behave tags (Behave strips `@` from scenario tags)
+- `tags.py` `@needs_data` now sets attribute on context in addition to `_behave_data_loaded`
+- `tags.py` cleanup functions now support both `func(context)` and `func()` signatures
+
+### Changed
+
+- Coverage increased from 94% to 98%
+- Total tests: 411 passed, 1 skipped (pandas optional)
+
 ## [0.1.2] - 2026-07-17
 
 ### Fixed

{behave_data-0.1.2 → behave_data-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: behave-data
-Version: 0.1.2
+Version: 0.1.3
 Summary: Data management for Behave — typed tables, diff, dynamic examples, fixtures, secrets
 Project-URL: Homepage, https://github.com/MathiasPaulenko/behave-data
 Project-URL: Repository, https://github.com/MathiasPaulenko/behave-data

{behave_data-0.1.2 → behave_data-0.1.3}/behave_data/__init__.py

@@ -38,7 +38,7 @@ from behave_data.tags import process_tags_after_scenario, process_tags_before_sc
 from behave_data.typed_table import TypedTableWrapper, typed_wrap
 from behave_data.types import TYPE_CONVERTERS, convert_cell, parse_column_header, register_type
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 
 __all__ = [
     "BehaveDataError",

{behave_data-0.1.2 → behave_data-0.1.3}/behave_data/tags.py

@@ -29,15 +29,17 @@ def process_tags_before_scenario(context: Any, scenario: Any) -> None:
         context._behave_data_loaded = {}
 
     for tag in tags:
-        if tag.startswith("@needs_data:"):
-            name = tag[len("@needs_data:") :]
+        tag = tag.lstrip("@")
+        if tag.startswith("needs_data:"):
+            name = tag[len("needs_data:") :]
             data = context.data.fixture(name)
             context._behave_data_loaded[name] = data
-        elif tag.startswith("@with_fixture:"):
-            name = tag[len("@with_fixture:") :]
+            setattr(context, name, data)
+        elif tag.startswith("with_fixture:"):
+            name = tag[len("with_fixture:") :]
             data = context.data.fixture(name)
             setattr(context, name, data)
-        elif tag == "@cleanup_after":
+        elif tag == "cleanup_after":
             context._behave_data_cleanup = True
             if not hasattr(context, "_behave_data_cleanup_funcs"):
                 context._behave_data_cleanup_funcs = []
@@ -58,6 +60,9 @@ def process_tags_after_scenario(context: Any, scenario: Any) -> None:
 
     funcs = getattr(context, "_behave_data_cleanup_funcs", [])
     for func in funcs:
-        func(context)
+        try:
+            func(context)
+        except TypeError:
+            func()
 
     context._behave_data_cleanup = False

{behave_data-0.1.2 → behave_data-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "behave-data"
-version = "0.1.2"
+version = "0.1.3"
 description = "Data management for Behave — typed tables, diff, dynamic examples, fixtures, secrets"
 readme = "README.md"
 license = "MIT"

behave_data-0.1.3/tests/integration/environment.py

@@ -0,0 +1,48 @@
+"""Behave environment for integration tests."""
+
+from __future__ import annotations
+
+from behave_data import (
+    after_scenario_hook,
+    before_feature_hook,
+    before_scenario_hook,
+    before_step_hook,
+    setup_data,
+)
+from behave_data.builders import data_builder
+from behave_data.fixtures import data_fixture
+
+
+@data_fixture("admin_user")
+def admin_user():
+    return {"name": "Admin", "role": "admin", "email": "admin@test.com"}
+
+
+@data_fixture("regular_user", params=["alice", "bob"])
+def regular_user(param):
+    return {"name": param, "role": "user"}
+
+
+@data_builder("product")
+def product(overrides):
+    return {"name": "Widget", "price": 9.99, **overrides}
+
+
+def before_all(context):
+    setup_data(context)
+
+
+def before_feature(context, feature):
+    before_feature_hook(context, feature)
+
+
+def before_scenario(context, scenario):
+    before_scenario_hook(context, scenario)
+
+
+def before_step(context, step):
+    before_step_hook(context, step)
+
+
+def after_scenario(context, scenario):
+    after_scenario_hook(context, scenario)

behave_data-0.1.3/tests/integration/features/data/products.json

@@ -0,0 +1,5 @@
+[
+  {"name": "Laptop", "price": "999.99"},
+  {"name": "Mouse", "price": "29.99"},
+  {"name": "Keyboard", "price": "79.99"}
+]

behave_data-0.1.3/tests/integration/features/data/users.csv

@@ -0,0 +1,4 @@
+name,email
+Alice,alice@example.com
+Bob,bob@example.com
+Carol,carol@example.com

behave_data-0.1.3/tests/integration/features/dynamic_examples.feature

@@ -0,0 +1,19 @@
+Feature: Dynamic examples E2E
+
+  @load_examples:csv:features/data/users.csv
+  Scenario Outline: Load users from CSV
+    Given a user with name "<name>" and email "<email>"
+    Then the user "<name>" should have email "<email>"
+
+    Examples:
+      | name | email |
+      | old  | old   |
+
+  @load_examples:json:features/data/products.json
+  Scenario Outline: Load products from JSON
+    Given a product with name "<name>" and price "<price>"
+    Then the product "<name>" should cost "<price>"
+
+    Examples:
+      | name | price |
+      | old  | old   |

behave_data-0.1.3/tests/integration/features/fixtures_builders.feature

@@ -0,0 +1,34 @@
+Feature: Fixtures and builders E2E
+
+  @needs_data:admin_user
+  Scenario: Admin user fixture is available via needs_data tag
+    Given I need an admin user
+    Then the admin user should have role "admin"
+    And the admin user should have email "admin@test.com"
+
+  @needs_data:regular_user:alice
+  Scenario: Parametrized fixture is available via needs_data tag
+    Given I need a regular user
+    Then the regular user should have name "alice"
+    And the regular user should have role "user"
+
+  Scenario: Build a single product via DataManager
+    Given I build a product
+    Then the product should have name "Widget"
+    And the product should have price 9.99
+
+  Scenario: Build a product with overrides
+    Given I build a product with name "Gadget" and price 19.99
+    Then the product should have name "Gadget"
+    And the product should have price 19.99
+
+  Scenario: Build multiple products
+    Given I build 3 products
+    Then I should have 3 products
+    And each product should have name "Widget"
+
+  @cleanup_after
+  Scenario: Cleanup after scenario
+    Given I register a cleanup function
+    Then the cleanup flag should be True
+    # After scenario, cleanup runs automatically via after_scenario_hook

behave_data-0.1.3/tests/integration/features/secrets.feature

@@ -0,0 +1,19 @@
+Feature: Secrets and placeholder resolution E2E
+
+  Scenario: Resolve env placeholder in step
+    Given I set environment variable "TEST_SECRET" to "my_secret_value"
+    When I resolve the placeholder "env:TEST_SECRET"
+    Then the resolved value should be "my_secret_value"
+
+  Scenario: Resolve plain text passthrough
+    When I resolve the placeholder "just_plain_text"
+    Then the resolved value should be "just_plain_text"
+
+  Scenario: Mask a resolved env value
+    Given I set environment variable "API_TOKEN" to "secret_token_123"
+    When I resolve and mask the placeholder "env:API_TOKEN"
+    Then the masked value should be "secret_token_123"
+
+  Scenario: Resolve integer passthrough
+    When I resolve the value 42
+    Then the resolved value should be "42"

behave_data-0.1.3/tests/integration/features/typed_table_edge.feature

@@ -0,0 +1,37 @@
+Feature: Typed table edge cases E2E
+
+  Scenario: All supported types in one table
+    Given a table with all types
+      | name:str | age:int | price:float | active:bool | created:date |
+      | Alice    | 30      | 99.99       | true        | 2024-01-15   |
+      | Bob      | 25      | 49.50       | false       | 2024-06-30   |
+    Then all types should be correctly converted
+      | name:str | age:int | price:float | active:bool | created:date |
+      | Alice    | 30      | 99.99       | true        | 2024-01-15   |
+      | Bob      | 25      | 49.50       | false       | 2024-06-30   |
+
+  Scenario: Nullable columns with null markers
+    Given a table with nullable typed columns
+      | name:str | age:int? | city:str? |
+      | Alice    | 30       | NYC       |
+      | Bob      | null     | N/A       |
+      | Carol    |          |           |
+    Then nullable columns should resolve nulls to None
+
+  Scenario: Empty table with typed headers
+    Given an empty typed table
+      | name:str | age:int |
+    Then the typed table should have 0 data rows
+
+  Scenario: Single column table
+    Given a single column table
+      | name:str |
+      | Alice    |
+    Then the single column should have one entry "Alice"
+
+  Scenario: Table with special characters
+    Given a table with special characters
+      | name:str | description:str |
+      | Alice    | A "quoted" value |
+      | Bob      | A 'single' value |
+    Then special characters should be preserved

behave_data-0.1.3/tests/integration/steps/e2e_steps.py

@@ -0,0 +1,247 @@
+"""E2E steps for fixtures, builders, secrets, typed tables, and dynamic examples."""
+
+from __future__ import annotations
+
+import os
+from datetime import date
+
+from behave import given, then, when
+
+from behave_data import typed_wrap
+
+# --------------------------------------------------------------------------- #
+# Fixtures & Builders
+# --------------------------------------------------------------------------- #
+
+
+@given("I need an admin user")
+def step_need_admin(context):
+    assert hasattr(context, "admin_user")
+    context.current_user = context.admin_user
+
+
+@then('the admin user should have role "{role}"')
+def step_admin_role(context, role):
+    assert context.current_user["role"] == role
+
+
+@then('the admin user should have email "{email}"')
+def step_admin_email(context, email):
+    assert context.current_user["email"] == email
+
+
+@given("I need a regular user")
+def step_need_regular(context):
+    loaded = getattr(context, "_behave_data_loaded", {})
+    # Find any regular_user:* fixture that was loaded
+    for key, val in loaded.items():
+        if key.startswith("regular_user:"):
+            context.current_user = val
+            return
+    raise AssertionError("No regular_user fixture loaded")
+
+
+@then('the regular user should have name "{name}"')
+def step_regular_name(context, name):
+    assert context.current_user["name"] == name
+
+
+@then('the regular user should have role "{role}"')
+def step_regular_role(context, role):
+    assert context.current_user["role"] == role
+
+
+@given("I build a product")
+def step_build_product(context):
+    context.product = context.data.build("product")
+
+
+@then('the product should have name "{name}"')
+def step_product_name(context, name):
+    assert context.product["name"] == name
+
+
+@then("the product should have price {price:f}")
+def step_product_price(context, price):
+    assert abs(context.product["price"] - price) < 0.01
+
+
+@given('I build a product with name "{name}" and price {price:f}')
+def step_build_product_overrides(context, name, price):
+    context.product = context.data.build("product", overrides={"name": name, "price": price})
+
+
+@given("I build {n:d} products")
+def step_build_multiple(context, n):
+    context.products = context.data.build("product", count=n)
+
+
+@then("I should have {n:d} products")
+def step_count_products(context, n):
+    assert len(context.products) == n
+
+
+@then('each product should have name "{name}"')
+def step_each_product_name(context, name):
+    for p in context.products:
+        assert p["name"] == name
+
+
+@given("I register a cleanup function")
+def step_register_cleanup(context):
+    context.cleanup_flag = False
+
+    def _cleanup():
+        context.cleanup_flag = False
+
+    if not hasattr(context, "_behave_data_cleanup_funcs"):
+        context._behave_data_cleanup_funcs = []
+    context._behave_data_cleanup_funcs.append(_cleanup)
+    context.cleanup_flag = True
+
+
+@then("the cleanup flag should be True")
+def step_cleanup_flag(context):
+    assert context.cleanup_flag is True
+
+
+# --------------------------------------------------------------------------- #
+# Secrets
+# --------------------------------------------------------------------------- #
+
+
+@given('I set environment variable "{var}" to "{value}"')
+def step_set_env(context, var, value):
+    os.environ[var] = value
+    context._env_var = var
+
+
+@when('I resolve the placeholder "{placeholder}"')
+def step_resolve(context, placeholder):
+    context.resolved = context.data.resolve(placeholder)
+
+
+@then('the resolved value should be "{value}"')
+def step_resolved_value(context, value):
+    assert str(context.resolved) == value
+
+
+@when('I resolve and mask the placeholder "{placeholder}"')
+def step_resolve_and_mask(context, placeholder):
+    raw = context.data.resolve(placeholder)
+    context.resolved = raw
+    context.masked = context.data.mask(raw)
+
+
+@then('the masked value should be "{value}"')
+def step_masked_value(context, value):
+    assert str(context.masked) == value
+
+
+@when("I resolve the value {val:d}")
+def step_resolve_int(context, val):
+    context.resolved = context.data.resolve(val)
+
+
+# --------------------------------------------------------------------------- #
+# Typed table edge cases
+# --------------------------------------------------------------------------- #
+
+
+@given("a table with all types")
+def step_all_types(context):
+    context.typed = typed_wrap(context.table).typed_dicts()
+
+
+@then("all types should be correctly converted")
+def step_check_all_types(context):
+    expected = typed_wrap(context.table).typed_dicts()
+    assert len(expected) == 2
+    assert isinstance(expected[0]["name"], str)
+    assert isinstance(expected[0]["age"], int)
+    assert isinstance(expected[0]["price"], float)
+    assert isinstance(expected[0]["active"], bool)
+    assert isinstance(expected[0]["created"], date)
+    assert expected[0]["active"] is True
+    assert expected[1]["active"] is False
+    assert expected[0]["created"] == date(2024, 1, 15)
+    assert expected[1]["created"] == date(2024, 6, 30)
+
+
+@given("a table with nullable typed columns")
+def step_nullable_typed(context):
+    context.typed = typed_wrap(context.table).typed_dicts()
+
+
+@then("nullable columns should resolve nulls to None")
+def step_check_nullable(context):
+    rows = context.typed
+    assert rows[0]["age"] == 30
+    assert rows[0]["city"] == "NYC"
+    assert rows[1]["age"] is None
+    assert rows[1]["city"] is None
+    assert rows[2]["age"] is None
+    assert rows[2]["city"] is None
+
+
+@given("an empty typed table")
+def step_empty_typed(context):
+    context.typed = typed_wrap(context.table)
+
+
+@then("the typed table should have 0 data rows")
+def step_zero_rows(context):
+    assert len(context.typed.typed_dicts()) == 0
+
+
+@given("a single column table")
+def step_single_col(context):
+    context.typed = typed_wrap(context.table).typed_dicts()
+
+
+@then('the single column should have one entry "{value}"')
+def step_single_entry(context, value):
+    rows = context.typed
+    assert len(rows) == 1
+    assert rows[0]["name"] == value
+
+
+@given("a table with special characters")
+def step_special_chars(context):
+    context.typed = typed_wrap(context.table).typed_dicts()
+
+
+@then("special characters should be preserved")
+def step_check_special(context):
+    rows = context.typed
+    assert "quoted" in rows[0]["description"]
+    assert "single" in rows[1]["description"]
+
+
+# --------------------------------------------------------------------------- #
+# Dynamic examples
+# --------------------------------------------------------------------------- #
+
+
+@given('a user with name "{name}" and email "{email}"')
+def step_user_with(context, name, email):
+    context.current_name = name
+    context.current_email = email
+
+
+@then('the user "{name}" should have email "{email}"')
+def step_user_email(context, name, email):
+    assert context.current_name == name
+    assert context.current_email == email
+
+
+@given('a product with name "{name}" and price "{price}"')
+def step_product_with(context, name, price):
+    context.current_product_name = name
+    context.current_product_price = price
+
+
+@then('the product "{name}" should cost "{price}"')
+def step_product_cost(context, name, price):
+    assert context.current_product_name == name
+    assert context.current_product_price == price