uto_manager/test/domain/entities/unit_node_test.dart

import 'package:flutter_test/flutter_test.dart';
import 'package:uto_manager/domain/entities/doctrinal_branch.dart';
import 'package:uto_manager/domain/entities/echelon.dart';
import 'package:uto_manager/domain/entities/unit_node.dart';

void main() {
  group('UnitNode', () {
    late UnitNode brigadeNode;
    late UnitNode battalionNode;
    late UnitNode companyNode;
    late UnitNode platoonNode;

    setUp(() {
      brigadeNode = const UnitNode(
        unitId: 'brigade-001',
        echelon: Echelon.brigade,
        branch: DoctrinalBranch.infantry,
        name: '1st Brigade Combat Team',
        isKeyLeader: false,
      );

      battalionNode = const UnitNode(
        unitId: 'battalion-001',
        echelon: Echelon.battalion,
        branch: DoctrinalBranch.infantry,
        name: '1-1 Infantry Battalion',
        isKeyLeader: false,
        parentUnitId: 'brigade-001',
      );

      companyNode = const UnitNode(
        unitId: 'company-001',
        echelon: Echelon.company,
        branch: DoctrinalBranch.infantry,
        name: 'Alpha Company',
        isKeyLeader: false,
        parentUnitId: 'battalion-001',
      );

      platoonNode = const UnitNode(
        unitId: 'platoon-001',
        echelon: Echelon.platoon,
        branch: DoctrinalBranch.infantry,
        name: '1st Platoon',
        isKeyLeader: false,
        parentUnitId: 'company-001',
      );
    });

    group('isRoot', () {
      test('brigade with no parent is a root node', () {
        expect(brigadeNode.isRoot, isTrue);
      });

      test('battalion with a parent is not a root node', () {
        expect(battalionNode.isRoot, isFalse);
      });
    });

    group('isValidParentNode', () {
      test('brigade is a valid parent for battalion', () {
        expect(battalionNode.isValidParentNode(brigadeNode), isTrue);
      });

      test('battalion is a valid parent for company', () {
        expect(companyNode.isValidParentNode(battalionNode), isTrue);
      });

      test('company is a valid parent for platoon', () {
        expect(platoonNode.isValidParentNode(companyNode), isTrue);
      });

      test('brigade is NOT a valid parent for company (skips echelon)', () {
        expect(companyNode.isValidParentNode(brigadeNode), isFalse);
      });

      test('platoon is NOT a valid parent for battalion', () {
        expect(battalionNode.isValidParentNode(platoonNode), isFalse);
      });

      test('same echelon is NOT a valid parent', () {
        const anotherBrigade = UnitNode(
          unitId: 'brigade-002',
          echelon: Echelon.brigade,
          branch: DoctrinalBranch.infantry,
          name: '2nd Brigade',
          isKeyLeader: false,
        );
        expect(brigadeNode.isValidParentNode(anotherBrigade), isFalse);
      });
    });

    group('copyWith', () {
      test('copies with updated name', () {
        final updated = brigadeNode.copyWith(name: 'Updated Brigade');
        expect(updated.name, equals('Updated Brigade'));
        expect(updated.unitId, equals(brigadeNode.unitId));
        expect(updated.echelon, equals(brigadeNode.echelon));
      });

      test('copies with updated parentUnitId', () {
        final updated = brigadeNode.copyWith(parentUnitId: 'new-parent-id');
        expect(updated.parentUnitId, equals('new-parent-id'));
      });

      test('clearParent removes parentUnitId', () {
        final updated = battalionNode.copyWith(clearParent: true);
        expect(updated.parentUnitId, isNull);
        expect(updated.isRoot, isTrue);
      });

      test('does not modify original', () {
        brigadeNode.copyWith(name: 'Modified');
        expect(brigadeNode.name, equals('1st Brigade Combat Team'));
      });
    });

    group('equality', () {
      test('two nodes with same fields are equal', () {
        const node1 = UnitNode(
          unitId: 'test-001',
          echelon: Echelon.platoon,
          branch: DoctrinalBranch.infantry,
          name: 'Test Platoon',
          isKeyLeader: false,
        );
        const node2 = UnitNode(
          unitId: 'test-001',
          echelon: Echelon.platoon,
          branch: DoctrinalBranch.infantry,
          name: 'Test Platoon',
          isKeyLeader: false,
        );
        expect(node1, equals(node2));
      });

      test('two nodes with different IDs are not equal', () {
        const node1 = UnitNode(
          unitId: 'test-001',
          echelon: Echelon.platoon,
          branch: DoctrinalBranch.infantry,
          name: 'Test Platoon',
          isKeyLeader: false,
        );
        const node2 = UnitNode(
          unitId: 'test-002',
          echelon: Echelon.platoon,
          branch: DoctrinalBranch.infantry,
          name: 'Test Platoon',
          isKeyLeader: false,
        );
        expect(node1, isNot(equals(node2)));
      });
    });

    group('toString', () {
      test('includes key fields in string representation', () {
        final str = brigadeNode.toString();
        expect(str, contains('brigade-001'));
        expect(str, contains('1st Brigade Combat Team'));
        expect(str, contains('Brigade'));
      });
    });
  });
}