docx_view_test.dart

import 'dart:typed_data';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:docx_viewer/docx_viewer.dart';
import '../fixtures/test_docx_generator.dart';

void main() {
  group('DocxView Widget', () {
    testWidgets('should display content after loading with bytes parameter',
        (WidgetTester tester) async {
      // Arrange
      final docxBytes = TestDocxGenerator.createSimpleDocx('Test content');

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(bytes: docxBytes),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      expect(find.text('Test content'), findsOneWidget);
      expect(find.byType(CircularProgressIndicator), findsNothing);
    });

    testWidgets('should apply custom font size', (WidgetTester tester) async {
      // Arrange
      final docxBytes = TestDocxGenerator.createSimpleDocx('Test content');
      const customFontSize = 24;

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(
              bytes: docxBytes,
              fontSize: customFontSize,
            ),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      final textWidget = tester.widget<Text>(find.text('Test content'));
      expect(textWidget.style?.fontSize, equals(customFontSize.toDouble()));
    });

    testWidgets('should use default font size when not specified',
        (WidgetTester tester) async {
      // Arrange
      final docxBytes = TestDocxGenerator.createSimpleDocx('Test content');

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(bytes: docxBytes),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      final textWidget = tester.widget<Text>(find.text('Test content'));
      expect(textWidget.style?.fontSize, equals(16.0)); // Default font size
    });

    testWidgets('should display multiple paragraphs with newlines',
        (WidgetTester tester) async {
      // Arrange
      final paragraphs = ['First line', 'Second line', 'Third line'];
      final docxBytes =
          TestDocxGenerator.createDocxWithMultipleParagraphs(paragraphs);

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(bytes: docxBytes),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      expect(find.text('First line\nSecond line\nThird line'), findsOneWidget);
    });

    testWidgets('should handle empty document', (WidgetTester tester) async {
      // Arrange
      final docxBytes = TestDocxGenerator.createEmptyDocx();

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(bytes: docxBytes),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      expect(find.text(''), findsOneWidget);
    });

    testWidgets('should call onError callback when no input provided',
        (WidgetTester tester) async {
      // Arrange
      Exception? capturedError;
      void onErrorCallback(Exception error) {
        capturedError = error;
      }

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(
              onError: onErrorCallback,
            ),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      expect(capturedError, isNotNull);
      expect(
        capturedError.toString(),
        contains('No input provided'),
      );
    });

    testWidgets(
        'should display error message when no input provided and no callback',
        (WidgetTester tester) async {
      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      expect(find.textContaining('No input provided'), findsOneWidget);
    });

    testWidgets('should call onError when both filePath and bytes are provided',
        (WidgetTester tester) async {
      // Arrange
      final docxBytes = TestDocxGenerator.createSimpleDocx('Test');
      Exception? capturedError;
      void onErrorCallback(Exception error) {
        capturedError = error;
      }

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(
              filePath: 'test.docx',
              bytes: docxBytes,
              onError: onErrorCallback,
            ),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      expect(capturedError, isNotNull);
      expect(
        capturedError.toString(),
        contains('Define only one of'),
      );
    });

    testWidgets(
        'should display error when both filePath and bytes provided without callback',
        (WidgetTester tester) async {
      // Arrange
      final docxBytes = TestDocxGenerator.createSimpleDocx('Test');

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(
              filePath: 'test.docx',
              bytes: docxBytes,
            ),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      expect(find.textContaining('Define only one of'), findsOneWidget);
    });

    testWidgets('should handle invalid bytes gracefully',
        (WidgetTester tester) async {
      // Arrange
      final invalidBytes = Uint8List.fromList([1, 2, 3, 4, 5]);
      Exception? capturedError;

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(
              bytes: invalidBytes,
              onError: (error) {
                capturedError = error;
              },
            ),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      expect(capturedError, isNotNull);
      expect(capturedError.toString(), contains('Error reading file'));
    });

    testWidgets('should render content in a scrollable view',
        (WidgetTester tester) async {
      // Arrange
      final docxBytes = TestDocxGenerator.createDocxWithMultipleParagraphs(
        List.generate(100, (i) => 'Line $i'),
      );

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(bytes: docxBytes),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      expect(find.byType(SingleChildScrollView), findsOneWidget);
    });

    testWidgets(
        'should display "No content to display" when fileContent is null',
        (WidgetTester tester) async {
      // This test ensures the fallback message is shown
      // We test this indirectly by checking the default display

      // Arrange
      final docxBytes = TestDocxGenerator.createEmptyDocx();

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(bytes: docxBytes),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert - empty content should just show empty text, not "No content to display"
      expect(find.byType(Text), findsWidgets);
    });

    testWidgets('should handle numbered lists correctly',
        (WidgetTester tester) async {
      // Arrange
      final items = ['First item', 'Second item', 'Third item'];
      final docxBytes = TestDocxGenerator.createDocxWithNumbering(items);

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(bytes: docxBytes),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      final textFinder = find.byType(Text);
      expect(textFinder, findsWidgets);

      final textWidget = tester.widget<Text>(textFinder.first);
      expect(textWidget.data, contains('1. First item'));
      expect(textWidget.data, contains('2. Second item'));
      expect(textWidget.data, contains('3. Third item'));
    });

    testWidgets('should apply correct padding', (WidgetTester tester) async {
      // Arrange
      final docxBytes = TestDocxGenerator.createSimpleDocx('Test content');

      // Act
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: DocxView(bytes: docxBytes),
          ),
        ),
      );
      await tester.pumpAndSettle();

      // Assert
      final container = tester.widget<Container>(find.byType(Container).first);
      expect(container.padding, equals(const EdgeInsets.all(10.0)));
    });
  });
}