Fix toggling toolbar between two editors (#229)

packages/zefyr/lib/src/widgets/editor.dart

@@ -90,7 +90,7 @@ class _ZefyrEditorState extends State<ZefyrEditor> {
 
   void hideToolbar() {
     if (_toolbarKey == null) return;
-    _scaffold.hideToolbar();
+    _scaffold.hideToolbar(buildToolbar);
     _toolbarKey = null;
   }
 

packages/zefyr/lib/src/widgets/mode.dart

@@ -58,4 +58,9 @@ class ZefyrMode {
 
   @override
   int get hashCode => hash3(canEdit, canSelect, canFormat);
+
+  @override
+  String toString() {
+    return 'ZefyrMode(canEdit: $canEdit, canSelect: $canSelect, canFormat: $canFormat)';
+  }
 }

packages/zefyr/lib/src/widgets/scaffold.dart

@@ -27,8 +27,8 @@ class ZefyrScaffoldState extends State<ZefyrScaffold> {
     });
   }
 
-  void hideToolbar() {
-    if (_toolbarBuilder != null) {
+  void hideToolbar(WidgetBuilder builder) {
+    if (_toolbarBuilder == builder) {
       setState(() {
         _toolbarBuilder = null;
       });

packages/zefyr/test/testing.dart

@@ -119,9 +119,9 @@ class EditorSandBox {
 class _ZefyrSandbox extends StatefulWidget {
   const _ZefyrSandbox({
     Key key,
-    this.controller,
-    this.focusNode,
-    this.autofocus,
+    @required this.controller,
+    @required this.focusNode,
+    this.autofocus = false,
     this.imageDelegate,
   }) : super(key: key);
   final ZefyrController controller;
@@ -153,3 +153,94 @@ class _ZefyrSandboxState extends State<_ZefyrSandbox> {
     });
   }
 }
+
+class MultiEditorSandbox {
+  final WidgetTester tester;
+  final Key firstEditorKey;
+  final Key secondEditorKey;
+  final FocusNode firstFocusNode;
+  final FocusNode secondFocusNode;
+  final Widget widget;
+
+  factory MultiEditorSandbox({@required WidgetTester tester}) {
+    final firstEditorKey = UniqueKey();
+    final secondEditorKey = UniqueKey();
+    final firstFocusNode = FocusNode();
+    final secondFocusNode = FocusNode();
+    Widget first = _ZefyrSandbox(
+      key: firstEditorKey,
+      controller: ZefyrController(NotusDocument.fromDelta(delta)),
+      focusNode: firstFocusNode,
+    );
+    Widget second = _ZefyrSandbox(
+      key: secondEditorKey,
+      controller: ZefyrController(NotusDocument.fromDelta(delta)),
+      focusNode: secondFocusNode,
+    );
+
+    Widget widget = MaterialApp(
+      home: Scaffold(
+        body: ZefyrScaffold(
+          child: Column(
+            children: <Widget>[
+              SizedBox(height: 100, child: first),
+              SizedBox(height: 10),
+              SizedBox(height: 100, child: second),
+            ],
+          ),
+        ),
+      ),
+    );
+
+    return MultiEditorSandbox._(
+      tester: tester,
+      widget: widget,
+      firstEditorKey: firstEditorKey,
+      secondEditorKey: secondEditorKey,
+      firstFocusNode: firstFocusNode,
+      secondFocusNode: secondFocusNode,
+    );
+  }
+
+  MultiEditorSandbox._({
+    @required this.tester,
+    @required this.widget,
+    @required this.firstEditorKey,
+    @required this.secondEditorKey,
+    @required this.firstFocusNode,
+    @required this.secondFocusNode,
+  });
+
+  Future<void> pump() async {
+    await tester.pumpWidget(widget);
+  }
+
+  Future<void> tapFirstEditor() async {
+    await tester.tap(find.byKey(firstEditorKey).first);
+    await tester.pumpAndSettle();
+  }
+
+  Future<void> tapSecondEditor() async {
+    await tester.tap(find.byKey(secondEditorKey).first);
+    await tester.pumpAndSettle();
+  }
+
+  ZefyrEditor findFirstEditor() {
+    return tester.widget(find.descendant(
+      of: find.byKey(firstEditorKey),
+      matching: find.byType(ZefyrEditor),
+    ));
+  }
+
+  ZefyrEditor findSecondEditor() {
+    return tester.widget(find.descendant(
+      of: find.byKey(secondEditorKey),
+      matching: find.byType(ZefyrEditor),
+    ));
+  }
+
+  Future<void> tapButtonWithIcon(IconData icon) async {
+    await tester.tap(find.widgetWithIcon(ZefyrButton, icon));
+    await tester.pumpAndSettle();
+  }
+}

packages/zefyr/test/widgets/editor_test.dart

@@ -46,5 +46,33 @@ void main() {
       ZefyrEditor widget = tester.widget(find.byType(ZefyrEditor));
       expect(widget.mode, ZefyrMode.view);
     });
+
+    testWidgets('toggle toolbar between two editors', (tester) async {
+      final sandbox = MultiEditorSandbox(tester: tester);
+      await sandbox.pump();
+      await sandbox.tapFirstEditor();
+      expect(sandbox.firstFocusNode.hasFocus, isTrue);
+      expect(sandbox.secondFocusNode.hasFocus, isFalse);
+      expect(find.byIcon(Icons.format_list_bulleted), findsOneWidget);
+
+      await sandbox.tapButtonWithIcon(Icons.format_list_bulleted);
+      ZefyrEditor widget = sandbox.findFirstEditor();
+      Node line = widget.controller.document.root.children.first;
+      expect(line, isInstanceOf<BlockNode>());
+      BlockNode block = line;
+      expect(block.style.contains(NotusAttribute.block.bulletList), isTrue);
+
+      await sandbox.tapSecondEditor();
+      expect(sandbox.firstFocusNode.hasFocus, isFalse);
+      expect(sandbox.secondFocusNode.hasFocus, isTrue);
+      expect(find.byIcon(Icons.format_list_bulleted), findsOneWidget);
+
+      await sandbox.tapButtonWithIcon(Icons.format_list_bulleted);
+      widget = sandbox.findSecondEditor();
+      line = widget.controller.document.root.children.first;
+      expect(line, isInstanceOf<BlockNode>());
+      block = line;
+      expect(block.style.contains(NotusAttribute.block.bulletList), isTrue);
+    });
   });
 }