[Intermediate]: Improve unit test coverage for src/hiero_sdk_python/hbar.py

[exploreriii]

🧩 Intermediate Contributors

This issue is intended for contributors who already have some familiarity with the
Hiero Python SDK codebase and contribution workflow.

You should feel comfortable:

• navigating existing source code and examples
• understanding SDK concepts without step-by-step guidance
• following the standard PR workflow without additional onboarding

If this is your very first contribution to the project, we recommend starting with a few
Good First Issues before working on this one.

🐞 Problem Description

Describe the problem here.
we have some tests: tests/unit/hbar_test.py

for
src/hiero_sdk_python/hbar.py

You can see we reach very high coverage, but some areas remain untested
https://app.codecov.io/gh/hiero-ledger/hiero-sdk-python/blob/main/src%2Fhiero_sdk_python%2Fhbar.py

💡 Expected Solution

Improve the test coverage for hbar.py, following https://app.codecov.io/gh/hiero-ledger/hiero-sdk-python/blob/main/src%2Fhiero_sdk_python%2Fhbar.py red suggestions

🧠 Implementation Notes

Edit
tests/unit/hbar_test.py

Possibly Missing Coverage Ideas:
(please do not attempt to do all! a general improvement is good

• from_tinybars() input validation
• Non-int inputs (e.g., float, Decimal, str)
• Fractional tinybar rejection via non-TINYBAR units
  e.g., Hbar(0.000000001, unit=HBAR)
  String representation methods
• str formatting (8 decimal places, negatives)
• repr output
• Hash behavior
• Consistency for equal values
• Set/dict compatibility
• Comparison operators with non-Hbar types
• <, >, <=, >= should raise TypeError
• from_string() default unit override
• When no unit is provided in the string
• Regex edge cases in from_string()
• Spacing, leading zeros, tabs, multiple spaces
• Precision boundary checks
• Reject values smaller than 1 tinybar
• MAX/MIN boundary behavior
• Comparisons around defined limits

✅ Acceptance Criteria

To merge this issue, the pull request must:

• Fully address the problem described above
• Follow existing project conventions and patterns
• Include tests or example updates where appropriate
• Pass all CI checks
• Include a valid changelog entry
• Use DCO and GPG-signed commits

📚 Additional Context or Resources

• SDK Developer Docs
• SDK Developer Training

[github-actions]

@coderabbitai plan

[coderabbitai]

Coding Plan

Approach

Improve unit test coverage for the Hbar class by adding tests for currently uncovered code paths and edge cases identified in the CodeCov report, focusing on input validation, string methods, hash behavior, comparison operators, parsing edge cases, and boundary conditions.

Observations

The Hiero Python SDK uses a function-based pytest testing approach with shared fixtures in conftest.py. Tests for the Hbar class are located in tests/unit/hbar_test.py and already cover basic constructor usage, unit conversions, and string parsing.

The Hbar class (src/hiero_sdk_python/hbar.py) is a value object with:

• 13 public/class methods
• 8 magic methods
• Validation logic
• 7 unit denominations

Current test coverage is high but has gaps in:

• Input validation edge cases
• String representation testing
• Hash behavior verification
• Comparison operator type safety
• Parsing edge cases
• Boundary conditions

Implementation Steps

Expand Test Coverage for Hbar Class

Add new test functions to tests/unit/hbar_test.py covering previously untested code paths and edge cases. Tests should follow existing patterns: function-based organization, @pytest.mark.parametrize for multiple scenarios, pytest.raises() for exception testing with message matching, and plain assert statements.

Task 1: Add Input Validation Tests

Add tests to verify proper rejection of invalid inputs and fractional tinybar values:

• Add test for from_tinybars() with non-int inputs (float, Decimal, string) that should raise TypeError
• Add parametrized test for constructor with fractional tinybar amounts through non-TINYBAR units (e.g., Hbar(0.000000001, unit=HbarUnit.HBAR)) that should raise ValueError
• Test negative tinybar values via from_tinybars() to ensure they are accepted (negative amounts are valid)

Task 2: Add String Representation Tests

Add tests verifying __str__ and __repr__ output formatting:

• Test __str__ formatting for positive values (should show 8 decimal places with ℏ symbol)
• Test __str__ formatting for negative values (should show minus sign with 8 decimal places)
• Test __str__ formatting for zero and class constants (ZERO, MAX, MIN)
• Test __repr__ output format matches expected pattern Hbar(value)

Task 3: Add Hash Behavior Tests

Add tests verifying hash consistency and collection compatibility:

• Test that equal Hbar values produce identical hashes (e.g., Hbar(100) and Hbar.from_tinybars(10000000000))
• Test that different Hbar values produce different hashes (not strictly required but generally expected)
• Test that Hbar objects can be used as dictionary keys
• Test that Hbar objects can be stored in sets and that duplicate values are properly deduplicated

Task 4: Add Comparison Operator Type Safety Tests

Add parametrized tests verifying comparison operators reject non-Hbar types:

• Use @pytest.mark.parametrize to test all comparison operators (<, >, <=, >=) with non-Hbar types (int, float, string, None)
• Each should raise TypeError when comparing Hbar with incompatible types
• Note: __eq__ and __ne__ may return False rather than raising (verify existing behavior and test accordingly)

Task 5: Add from_string Edge Case Tests

Add tests for string parsing edge cases and default unit behavior:

• Test from_string() with explicit default unit parameter when string has no unit suffix
• Test from_string() with strings containing leading zeros (e.g., "00123.45 ℏ")
• Test from_string() with extra whitespace (spaces before/after number, multiple spaces before unit)
• Test from_string() with tab characters (should likely fail regex validation)
• Test from_string() with very large/small numeric values that would exceed tinybar precision

Task 6: Add Boundary and Limit Tests

Add tests verifying behavior at precision limits and MAX/MIN boundaries:

• Test that values smaller than 1 tinybar are rejected (e.g., through unit conversion that would produce fractional tinybars)
• Test comparison operations near MAX and MIN boundaries (e.g., Hbar.MAX > Hbar.MIN, Hbar.MAX == Hbar(50_000_000_000))
• Test arithmetic that would approach or exceed MAX/MIN limits if such operations exist (verify if negation of MAX/MIN is handled)
• Test equality comparisons between boundary constants and equivalent manually constructed values

🤖 Prompt for AI agents

Expand test coverage for the Hbar class by adding comprehensive tests for
previously untested code paths and edge cases in `tests/unit/hbar_test.py`.

Follow existing test patterns:
- Function-based organization
- Use `@pytest.mark.parametrize` for multiple scenarios
- Use `pytest.raises()` for exception testing with message matching
- Use plain `assert` statements for assertions

Add the following test categories:

**Input Validation Tests:**
- Test `from_tinybars()` rejects non-int inputs (float, Decimal, string) with
TypeError
- Test constructor rejects fractional tinybar amounts through non-TINYBAR units
with ValueError
- Test negative tinybar values are accepted via `from_tinybars()`

**String Representation Tests:**
- Test `__str__` formatting for positive, negative, zero values and class
constants (8 decimals with ℏ symbol)
- Test `__repr__` output format matches `Hbar(value)` pattern

**Hash Behavior Tests:**
- Test equal Hbar values produce identical hashes
- Test different values produce different hashes
- Test Hbar objects work as dictionary keys and in sets with proper
deduplication

**Comparison Operator Type Safety Tests:**
- Parametrize tests for `<`, `>`, `<=`, `>=` operators with non-Hbar types (int,
float, string, None)
- Verify TypeError is raised for incompatible types
- Handle `__eq__` and `__ne__` appropriately (may return False instead of
raising)

**from_string Edge Case Tests:**
- Test with explicit default unit parameter
- Test with leading zeros, extra whitespace, tab characters
- Test with very large/small numeric values exceeding tinybar precision

**Boundary and Limit Tests:**
- Test rejection of values smaller than 1 tinybar
- Test comparisons at MAX/MIN boundaries
- Test arithmetic near limits and negation of MAX/MIN
- Test equality between boundary constants and equivalent constructed values

---

🚀 Next Steps

🤖 All AI agent prompts combined

Expand test coverage for the Hbar class by adding comprehensive tests for
previously untested code paths and edge cases in `tests/unit/hbar_test.py`.

Follow existing test patterns:
- Function-based organization
- Use `@pytest.mark.parametrize` for multiple scenarios
- Use `pytest.raises()` for exception testing with message matching
- Use plain `assert` statements for assertions

Add the following test categories:

**Input Validation Tests:**
- Test `from_tinybars()` rejects non-int inputs (float, Decimal, string) with
TypeError
- Test constructor rejects fractional tinybar amounts through non-TINYBAR units
with ValueError
- Test negative tinybar values are accepted via `from_tinybars()`

**String Representation Tests:**
- Test `__str__` formatting for positive, negative, zero values and class
constants (8 decimals with ℏ symbol)
- Test `__repr__` output format matches `Hbar(value)` pattern

**Hash Behavior Tests:**
- Test equal Hbar values produce identical hashes
- Test different values produce different hashes
- Test Hbar objects work as dictionary keys and in sets with proper
deduplication

**Comparison Operator Type Safety Tests:**
- Parametrize tests for `<`, `>`, `<=`, `>=` operators with non-Hbar types (int,
float, string, None)
- Verify TypeError is raised for incompatible types
- Handle `__eq__` and `__ne__` appropriately (may return False instead of
raising)

**from_string Edge Case Tests:**
- Test with explicit default unit parameter
- Test with leading zeros, extra whitespace, tab characters
- Test with very large/small numeric values exceeding tinybar precision

**Boundary and Limit Tests:**
- Test rejection of values smaller than 1 tinybar
- Test comparisons at MAX/MIN boundaries
- Test arithmetic near limits and negation of MAX/MIN
- Test equality between boundary constants and equivalent constructed values

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- @coderabbitai You can skip phase 3. Add a simple unit test case for phase 2.
- @coderabbitai For assumption 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!

[CODEAbhinav-art]

/assign