Fix TB2::OnlyOnePlan so it doesn't store state.

This lets use the same handler in multiple test states.

Needed by TBT which copies all the handlers to emulate the test behavior.

For #242

lib/TB2/OnlyOnePlan.pm

@@ -70,28 +70,20 @@ This specificially allows redundant planning...
 
 =cut
 
-has existing_plan =>
-  is            => 'rw',
-  isa           => 'Object',
-;
-
 sub handle_set_plan {
     my $self  = shift;
-    my $event = shift;
-
-    $self->already_saw_plan($event) if $self->existing_plan;
+    my($plan, $ec) = @_;
 
-    $self->existing_plan($event);
+    my $existing_plan = $ec->history->plan;
+    $self->_already_saw_plan($existing_plan, $plan) if $existing_plan;
 
     return;
 }
 
 
-sub already_saw_plan {
+sub _already_saw_plan {
     my $self = shift;
-    my $new_plan = shift;
-
-    my $existing_plan = $self->existing_plan;
+    my($existing_plan, $new_plan) = @_;
 
     return if $existing_plan->no_plan &&
               ( $new_plan->no_plan || $new_plan->asserts_expected );

lib/Test/Builder/Tester.pm

@@ -93,6 +93,10 @@ sub _start_testing {
     # Make a detached TestState
     my $state = $original_state->create(
         formatters      => [$formatter],
+
+        # Preserve existing handlers
+        early_handlers  => $original_state->early_handlers,
+        late_handlers   => $original_state->late_handlers,
     );
 
     # remember that we're testing

t/OnlyOnePlan/basics.t

@@ -6,16 +6,21 @@ use warnings;
 BEGIN { require "t/test.pl" }
 
 use TB2::Events;
+use TB2::EventCoordinator;
 
 my $CLASS = 'TB2::OnlyOnePlan';
 use_ok $CLASS;
 
 
 note "Two different plans are not ok"; {
     my $onlyone = $CLASS->new;
+    my $ec = TB2::EventCoordinator->new(
+        formatters      => [],
+        early_handlers  => [$onlyone]
+    );
 
     ok eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(
                 asserts_expected => 3,
                 file             => "bar.t",
@@ -26,7 +31,7 @@ note "Two different plans are not ok"; {
     }, "one plan is ok";
 
     ok !eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(
                 asserts_expected => 1,
                 file             => "foo.t",
@@ -41,9 +46,13 @@ note "Two different plans are not ok"; {
 
 note "The same plan is ok"; {
     my $onlyone = $CLASS->new;
+    my $ec = TB2::EventCoordinator->new(
+        formatters      => [],
+        early_handlers  => [$onlyone]
+    );
 
     ok eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(
                 asserts_expected => 3,
                 file             => "bar.t",
@@ -54,7 +63,7 @@ note "The same plan is ok"; {
     }, "one plan is ok";
 
     ok eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(
                 asserts_expected => 3,
                 file             => "foo.t",
@@ -68,30 +77,34 @@ note "The same plan is ok"; {
 
 note "Multiple no_plans are ok"; {
     my $onlyone = $CLASS->new;
+    my $ec = TB2::EventCoordinator->new(
+        formatters      => [],
+        early_handlers  => [$onlyone]
+    );
 
     ok eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(no_plan => 1)
         );
         1;
     }, "one no_plan is ok";
 
     ok eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(no_plan => 1)
         );
         1;
     }, "two no_plans are ok";
 
     ok eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(asserts_expected => 3)
         );
         1;
     }, "a fixed number of tests after a no_plan is ok";
 
     ok !eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(asserts_expected => 23)
         );
         1;
@@ -101,16 +114,20 @@ note "Multiple no_plans are ok"; {
 
 note "Error message with no file/line"; {
     my $onlyone = $CLASS->new;
+    my $ec = TB2::EventCoordinator->new(
+        formatters      => [],
+        early_handlers  => [$onlyone]
+    );
 
     ok eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(asserts_expected => 2)
         );
         1;
     }, "one plan is ok";
 
     ok !eval {
-        $onlyone->accept_event(
+        $ec->post_event(
             TB2::Event::SetPlan->new(
                 asserts_expected => 3,
             )

t/OnlyOnePlan/no_state.t

@@ -0,0 +1,55 @@
+#!/usr/bin/env perl -w
+
+use strict;
+use warnings;
+
+BEGIN { require "t/test.pl" }
+
+use TB2::Events;
+use TB2::EventCoordinator;
+
+my $CLASS = 'TB2::OnlyOnePlan';
+use_ok $CLASS;
+
+
+note "Two plans from two different coordinators to one handler is ok"; {
+    my $onlyone = $CLASS->new;
+
+    # Deliberately put the same handler into two coordinators
+    my $ec1 = TB2::EventCoordinator->new(
+        formatters      => [],
+        early_handlers  => [$onlyone]
+    );
+    my $ec2 = TB2::EventCoordinator->new(
+        formatters      => [],
+        early_handlers  => [$onlyone]
+    );
+
+    # start testing in both coordinators
+    my $start = TB2::Event::TestStart->new;
+    $_->post_event($start) for $ec1, $ec2;
+
+    ok eval {
+        $ec1->post_event(
+            TB2::Event::SetPlan->new(
+                asserts_expected => 3,
+                file             => "bar.t",
+                line             => 42,
+            )
+        );
+        1;
+    }, "one plan is ok" or diag $@;
+
+    ok eval {
+        $ec2->post_event(
+            TB2::Event::SetPlan->new(
+                asserts_expected => 4,
+                file             => "foo.t",
+                line             => 23,
+            )
+        );
+        1;
+    }, "a plan in another coordinator is ok" or diag $@;
+}
+
+done_testing;