File: actor_examples.rb

package info (click to toggle)
ruby-celluloid 0.16.0-5
  • links: PTS, VCS
  • area: main
  • in suites: bookworm, bullseye, buster
  • size: 776 kB
  • sloc: ruby: 5,308; makefile: 10
file content (1054 lines) | stat: -rw-r--r-- 27,717 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
shared_examples "a Celluloid Actor" do |included_module|
  describe "using Fibers" do
    include_examples "Celluloid::Actor examples", included_module, Celluloid::TaskFiber
  end
  describe "using Threads" do
    include_examples "Celluloid::Actor examples", included_module, Celluloid::TaskThread
  end
end

shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
  class ExampleCrash < StandardError
    attr_accessor :foo
  end

  let(:actor_class) { ExampleActorClass.create(included_module, task_klass) }

  it "returns the actor's class, not the proxy's" do
    actor = actor_class.new "Troy McClure"
    expect(actor.class).to eq(actor_class)
  end

  it "compares with the actor's class in a case statement" do
    expect(case actor_class.new("Troy McClure")
    when actor_class
      true
    else
      false
    end).to be_truthy
  end

  it "can be stored in hashes" do
    actor = actor_class.new "Troy McClure"
    expect(actor.hash).not_to eq(Kernel.hash)
    expect(actor.object_id).not_to eq(Kernel.object_id)
  end

  it "implements respond_to? correctly" do
    actor = actor_class.new 'Troy McClure'
    expect(actor).to respond_to(:alive?)
  end

  it "supports synchronous calls" do
    actor = actor_class.new "Troy McClure"
    expect(actor.greet).to eq("Hi, I'm Troy McClure")
  end

  it "supports synchronous calls with blocks" do
    actor = actor_class.new "Blocky Ralboa"

    block_executed = false
    actor.run { block_executed = true }
    expect(block_executed).to be_truthy
  end

  it "supports synchronous calls via #method" do
    method = actor_class.new("Troy McClure").method(:greet)
    expect(method.call).to eq("Hi, I'm Troy McClure")
  end

  it "supports #arity calls via #method" do
    method = actor_class.new("Troy McClure").method(:greet)
    expect(method.arity).to be(0)

    method = actor_class.new("Troy McClure").method(:change_name)
    expect(method.arity).to be(1)
  end

  it "supports #name calls via #method" do
    method = actor_class.new("Troy McClure").method(:greet)
    expect(method.name).to eq(:greet)
  end

  it "supports #parameters via #method" do
    method = actor_class.new("Troy McClure").method(:greet)
    expect(method.parameters).to eq([])

    method = actor_class.new("Troy McClure").method(:change_name)
    expect(method.parameters).to eq([[:req, :new_name]])
  end

  it "supports future(:method) syntax for synchronous future calls" do
    actor = actor_class.new "Troy McClure"
    future = actor.future :greet
    expect(future.value).to eq("Hi, I'm Troy McClure")
  end

  it "supports future.method syntax for synchronous future calls" do
    actor = actor_class.new "Troy McClure"
    future = actor.future.greet
    expect(future.value).to eq("Hi, I'm Troy McClure")
  end

  it "handles circular synchronous calls" do
    klass = Class.new do
      include included_module
      task_class task_klass

      def greet_by_proxy(actor)
        actor.greet
      end

      def to_s
        "a ponycopter!"
      end
    end

    ponycopter = klass.new
    actor = actor_class.new ponycopter
    expect(ponycopter.greet_by_proxy(actor)).to eq("Hi, I'm a ponycopter!")
  end

  it "detects recursion" do
    klass1 = Class.new do
      include included_module
      task_class task_klass

      def recursion_test(recurse_through = nil)
        if recurse_through
          recurse_through.recursion_thunk(Celluloid::Actor.current)
        else
          Celluloid.detect_recursion
        end
      end
    end

    klass2 = Class.new do
      include included_module
      task_class task_klass

      def recursion_thunk(other)
        other.recursion_test
      end
    end

    actor1 = klass1.new
    actor2 = klass2.new

    expect(actor1.recursion_test).to be_falsey
    expect(actor1.recursion_test(actor2)).to be_truthy
  end

  it "properly handles method_missing" do
    actor = actor_class.new "Method Missing"
    expect(actor).to respond_to(:first)
    expect(actor.first).to be :bar
  end

  it "properly handles respond_to with include_private" do
    actor = actor_class.new "Method missing privates"
    expect(actor.respond_to?(:zomg_private)).to be_falsey
    expect(actor.respond_to?(:zomg_private, true)).to be_truthy
  end

  it "warns about suspending the initialize" do
    klass = Class.new do
      include included_module
      task_class task_klass

      def initialize
        sleep 0.1
      end
    end

    expect(Celluloid.logger).to receive(:warn).with(/Dangerously suspending task: type=:call, meta={:method_name=>:initialize}, status=:sleeping/)

    actor = klass.new
    actor.terminate
    Celluloid::Actor.join(actor) unless defined?(JRUBY_VERSION)
  end

  it "calls the user defined finalizer" do
    actor = actor_class.new "Mr. Bean"
    expect(actor.wrapped_object).to receive(:my_finalizer)
    actor.terminate
    Celluloid::Actor.join(actor)
  end

  it "warns about suspending the finalizer" do
    klass = Class.new do
      include included_module
      task_class task_klass

      finalizer :cleanup

      def cleanup
        sleep 0.1
      end
    end

    expect(Celluloid.logger).to receive(:warn).with(/Dangerously suspending task: type=:finalizer, meta={:method_name=>:cleanup}, status=:sleeping/)

    actor = klass.new
    actor.terminate
    Celluloid::Actor.join(actor)
  end

  it "supports async(:method) syntax for asynchronous calls" do
    actor = actor_class.new "Troy McClure"
    actor.async :change_name, "Charlie Sheen"
    expect(actor.greet).to eq("Hi, I'm Charlie Sheen")
  end

  it "supports async.method syntax for asynchronous calls" do
    actor = actor_class.new "Troy McClure"
    actor.async.change_name "Charlie Sheen"
    expect(actor.greet).to eq("Hi, I'm Charlie Sheen")
  end

  it "supports async.method syntax for asynchronous calls to itself" do
    actor = actor_class.new "Troy McClure"
    actor.change_name_async "Charlie Sheen"
    expect(actor.greet).to eq("Hi, I'm Charlie Sheen")
  end

  it "allows an actor to call private methods asynchronously" do
    actor = actor_class.new "Troy McClure"
    actor.call_private
    expect(actor.private_called).to be_truthy
  end

  it "knows if it's inside actor scope" do
    expect(Celluloid).not_to be_actor
    actor = actor_class.new "Troy McClure"
    expect(actor.run do
      Celluloid.actor?
    end).to be_falsey
    expect(actor.run_on_receiver do
      Celluloid.actor?
    end).to be_truthy
    expect(actor).to be_actor
  end

  it "inspects properly" do
    actor = actor_class.new "Troy McClure"
    expect(actor.inspect).to match(/Celluloid::CellProxy\(/)
    expect(actor.inspect).to match(/#{actor_class}/)
    expect(actor.inspect).to include('@name="Troy McClure"')
    expect(actor.inspect).not_to include("@celluloid")
  end

  it "inspects properly when dead" do
    actor = actor_class.new "Troy McClure"
    actor.terminate
    expect(actor.inspect).to match(/Celluloid::CellProxy\(/)
    expect(actor.inspect).to match(/#{actor_class}/)
    expect(actor.inspect).to include('dead')
  end

  it "supports recursive inspect with other actors" do
    klass = Class.new do
      include included_module
      task_class task_klass

      attr_accessor :other

      def initialize(other = nil)
        @other = other
      end
    end

    itchy = klass.new
    scratchy = klass.new(itchy)
    itchy.other = scratchy

    inspection = itchy.inspect
    expect(inspection).to match(/Celluloid::CellProxy\(/)
    expect(inspection).to include("...")
  end

  it "allows access to the wrapped object" do
    actor = actor_class.new "Troy McClure"
    expect(actor.wrapped_object).to be_a actor_class
  end

  it "warns about leaked wrapped objects via #inspect" do
    actor = actor_class.new "Troy McClure"

    expect(actor.inspect).not_to include Celluloid::BARE_OBJECT_WARNING_MESSAGE
    expect(actor.inspect_thunk).not_to include Celluloid::BARE_OBJECT_WARNING_MESSAGE
    expect(actor.wrapped_object.inspect).to include Celluloid::BARE_OBJECT_WARNING_MESSAGE
  end

  it "can override #send" do
    actor = actor_class.new "Troy McClure"
    expect(actor.send('foo')).to eq('oof')
  end

  context "when executing under JRuby" do
    let(:klass) {
      Class.new do
        include included_module
        task_class task_klass

        def current_thread_name
          java_thread.get_name
        end

        def java_thread
          Thread.current.to_java.getNativeThread
        end
      end
    }

    it "sets execution info" do
      expect(klass.new.current_thread_name).to eq("Class#current_thread_name")
    end

    it "unsets execution info after task completion" do
      expect(klass.new.java_thread.get_name).to eq("<unused>")
    end
  end if RUBY_PLATFORM == "java"

  context "mocking methods" do
    let(:actor) { actor_class.new "Troy McClure" }

    before do
      expect(actor.wrapped_object).to receive(:external_hello).once.and_return "World"
    end

    it "works externally via the proxy" do
      expect(actor.external_hello).to eq("World")
    end

    it "works internally when called on self" do
      expect(actor.internal_hello).to eq("World")
    end
  end

  context :exceptions do
    it "reraises exceptions which occur during synchronous calls in the sender" do
      actor = actor_class.new "James Dean" # is this in bad taste?

      expect do
        actor.crash
      end.to raise_exception(ExampleCrash)
    end

    it "includes both sender and receiver in exception traces" do
      example_receiver = Class.new do
        include included_module
        task_class task_klass

        define_method(:receiver_method) do
          raise ExampleCrash, "the spec purposely crashed me :("
        end
      end

      excample_caller = Class.new do
        include included_module
        task_class task_klass

        define_method(:sender_method) do
          example_receiver.new.receiver_method
        end
      end

      ex = nil
      begin
        excample_caller.new.sender_method
      rescue => ex
      end

      expect(ex).to be_a ExampleCrash
      expect(ex.backtrace.grep(/`sender_method'/)).to be_truthy
      expect(ex.backtrace.grep(/`receiver_method'/)).to be_truthy
    end

    it "raises DeadActorError if methods are synchronously called on a dead actor" do
      actor = actor_class.new "James Dean"
      actor.crash rescue nil

      sleep 0.1 # hax to prevent a race between exit handling and the next call

      expect do
        actor.greet
      end.to raise_exception(Celluloid::DeadActorError)
    end
  end

  context :abort do
    it "raises exceptions in the sender but keeps running" do
      actor = actor_class.new "Al Pacino"

      expect do
        actor.crash_with_abort "You die motherfucker!", :bar
      end.to raise_exception(ExampleCrash, "You die motherfucker!")

      expect(actor).to be_alive
    end

    it "converts strings to runtime errors" do
      actor = actor_class.new "Al Pacino"
      expect do
        actor.crash_with_abort_raw "foo"
      end.to raise_exception(RuntimeError, "foo")
    end

    it "crashes the sender if we pass neither String nor Exception" do
      actor = actor_class.new "Al Pacino"
      expect do
        actor.crash_with_abort_raw 10
      end.to raise_exception(TypeError, "Exception object/String expected, but #{0.class} received")

      Celluloid::Actor.join(actor)
      expect(actor).not_to be_alive
    end
  end

  context :termination do
    it "terminates" do
      actor = actor_class.new "Arnold Schwarzenegger"
      expect(actor).to be_alive
      actor.terminate
      Celluloid::Actor.join(actor)
      expect(actor).not_to be_alive
    end

    it "can be terminated by a SyncCall" do
      actor = actor_class.new "Arnold Schwarzenegger"
      expect(actor).to be_alive
      actor.shutdown
      Celluloid::Actor.join(actor)
      expect(actor).not_to be_alive
    end

    it "kills" do # THOU SHALT ALWAYS KILL
      actor = actor_class.new "Woody Harrelson"
      expect(actor).to be_alive
      Celluloid::Actor.kill(actor)
      Celluloid::Actor.join(actor)
      expect(actor).not_to be_alive
    end

    it "raises DeadActorError if called after terminated" do
      actor = actor_class.new "Arnold Schwarzenegger"
      actor.terminate

      expect do
        actor.greet
      end.to raise_exception(Celluloid::DeadActorError)
    end

    it "terminates cleanly on Celluloid shutdown" do
      allow(Celluloid::Actor).to receive(:kill).and_call_original

      actor = actor_class.new "Arnold Schwarzenegger"

      Celluloid.shutdown
      expect(Celluloid::Actor).not_to have_received(:kill)
    end

    it "raises the right DeadActorError if terminate! called after terminated" do
      actor = actor_class.new "Arnold Schwarzenegger"
      actor.terminate

      expect do
        actor.terminate!
      end.to raise_exception(Celluloid::DeadActorError, "actor already terminated")
    end

    it "logs a warning when terminating tasks" do
      expect(Celluloid.logger).to receive(:warn).with(/^Terminating task: type=:call, meta={:method_name=>:sleepy}, status=:sleeping\n/)

      actor = actor_class.new "Arnold Schwarzenegger"
      actor.async.sleepy 10
      actor.greet # make sure the actor has started sleeping

      actor.terminate
    end
  end

  context :current_actor do
    it "knows the current actor" do
      actor = actor_class.new "Roger Daltrey"
      expect(actor.current_actor).to eq actor
    end

    it "raises NotActorError if called outside an actor" do
      expect do
        Celluloid.current_actor
      end.to raise_exception(Celluloid::NotActorError)
    end
  end

  context :linking do
    before :each do
      @kevin   = actor_class.new "Kevin Bacon" # Some six degrees action here
      @charlie = actor_class.new "Charlie Sheen"
    end

    let(:supervisor_class) do
      Class.new do # like a boss
        include included_module
        task_class task_klass
        trap_exit :lambaste_subordinate

        def initialize(name)
          @name = name
          @subordinate_lambasted = false
        end

        def subordinate_lambasted?; @subordinate_lambasted; end

        def lambaste_subordinate(actor, reason)
          @subordinate_lambasted = true
        end
      end
    end

    it "links to other actors" do
      @kevin.link @charlie
      expect(@kevin.monitoring?(@charlie)).to be_truthy
      expect(@kevin.linked_to?(@charlie)).to  be_truthy
      expect(@charlie.monitoring?(@kevin)).to be_truthy
      expect(@charlie.linked_to?(@kevin)).to  be_truthy
    end

    it "unlinks from other actors" do
      @kevin.link @charlie
      @kevin.unlink @charlie

      expect(@kevin.monitoring?(@charlie)).to be_falsey
      expect(@kevin.linked_to?(@charlie)).to  be_falsey
      expect(@charlie.monitoring?(@kevin)).to be_falsey
      expect(@charlie.linked_to?(@kevin)).to  be_falsey
    end

    it "monitors other actors unidirectionally" do
      @kevin.monitor @charlie

      expect(@kevin.monitoring?(@charlie)).to be_truthy
      expect(@kevin.linked_to?(@charlie)).to  be_falsey
      expect(@charlie.monitoring?(@kevin)).to be_falsey
      expect(@charlie.linked_to?(@kevin)).to  be_falsey
    end

    it "unmonitors other actors" do
      @kevin.monitor @charlie
      @kevin.unmonitor @charlie

      expect(@kevin.monitoring?(@charlie)).to be_falsey
      expect(@kevin.linked_to?(@charlie)).to  be_falsey
      expect(@charlie.monitoring?(@kevin)).to be_falsey
      expect(@charlie.linked_to?(@kevin)).to  be_falsey
    end

    it "traps exit messages from other actors" do
      chuck = supervisor_class.new "Chuck Lorre"
      chuck.link @charlie

      expect do
        @charlie.crash
      end.to raise_exception(ExampleCrash)

      sleep 0.1 # hax to prevent a race between exit handling and the next call
      expect(chuck).to be_subordinate_lambasted
    end

    it "traps exit messages from other actors in subclasses" do
      supervisor_subclass = Class.new(supervisor_class)
      chuck = supervisor_subclass.new "Chuck Lorre"
      chuck.link @charlie

      expect do
        @charlie.crash
      end.to raise_exception(ExampleCrash)

      sleep 0.1 # hax to prevent a race between exit handling and the next call
      expect(chuck).to be_subordinate_lambasted
    end

    it "unlinks from a dead linked actor" do
      chuck = supervisor_class.new "Chuck Lorre"
      chuck.link @charlie

      expect do
        @charlie.crash
      end.to raise_exception(ExampleCrash)

      sleep 0.1 # hax to prevent a race between exit handling and the next call
      expect(chuck.links.count).to be(0)
    end
  end

  context :signaling do
    before do
      @signaler = Class.new do
        include included_module
        task_class task_klass

        def initialize
          @waiting  = false
          @signaled = false
        end

        def wait_for_signal
          raise "already signaled" if @signaled

          @waiting = true
          value = wait :ponycopter

          @waiting = false
          @signaled = true
          value
        end

        def send_signal(value)
          signal :ponycopter, value
        end

        def waiting?; @waiting end
        def signaled?; @signaled end
      end
    end

    it "allows methods within the same object to signal each other" do
      obj = @signaler.new
      expect(obj).not_to be_signaled

      obj.async.wait_for_signal
      expect(obj).not_to be_signaled
      expect(obj).to be_waiting

      obj.send_signal :foobar
      expect(obj).to be_signaled
      expect(obj).not_to be_waiting
    end

    it "sends values along with signals" do
      obj = @signaler.new
      expect(obj).not_to be_signaled

      future = obj.future(:wait_for_signal)

      expect(obj).to be_waiting
      expect(obj).not_to be_signaled

      expect(obj.send_signal(:foobar)).to be_truthy
      expect(future.value).to be(:foobar)
    end
  end

  context :exclusive do
    subject do
      Class.new do
        include included_module
        task_class task_klass

        attr_reader :tasks

        def initialize
          @tasks = []
        end

        def log_task(task)
          @tasks << task
        end

        def exclusive_with_block_log_task(task)
          exclusive do
            sleep Celluloid::TIMER_QUANTUM
            log_task(task)
          end
        end

        def exclusive_log_task(task)
          sleep Celluloid::TIMER_QUANTUM
          log_task(task)
        end
        exclusive :exclusive_log_task

        def check_not_exclusive
          Celluloid.exclusive?
        end

        def check_exclusive
          exclusive { Celluloid.exclusive? }
        end

        def nested_exclusive_example
          exclusive { exclusive { nil }; Celluloid.exclusive? }
        end
      end.new
    end

    it "executes methods in the proper order with block form" do
      subject.async.exclusive_with_block_log_task(:one)
      subject.async.log_task(:two)
      sleep Celluloid::TIMER_QUANTUM * 2
      expect(subject.tasks).to eq([:one, :two])
    end

    it "executes methods in the proper order with a class-level annotation" do
      subject.async.exclusive_log_task :one
      subject.async.log_task :two
      sleep Celluloid::TIMER_QUANTUM * 2
      expect(subject.tasks).to eq([:one, :two])
    end

    it "knows when it's in exclusive mode" do
      expect(subject.check_not_exclusive).to be_falsey
      expect(subject.check_exclusive).to be_truthy
    end

    it "remains in exclusive mode inside nested blocks" do
      expect(subject.nested_exclusive_example).to be_truthy
    end
  end

  context "exclusive classes" do
    subject do
      Class.new do
        include included_module
        task_class task_klass
        exclusive

        attr_reader :tasks

        def initialize
          @tasks = []
        end

        def eat_donuts
          sleep Celluloid::TIMER_QUANTUM
          @tasks << 'donuts'
        end

        def drink_coffee
          @tasks << 'coffee'
        end
      end
    end

    it "executes two methods in an exclusive order" do
      actor = subject.new
      actor.async.eat_donuts
      actor.async.drink_coffee
      sleep Celluloid::TIMER_QUANTUM * 2
      expect(actor.tasks).to eq(['donuts', 'coffee'])
    end
  end

  context :receiving do
    before do
      @receiver = Class.new do
        include included_module
        task_class task_klass
        execute_block_on_receiver :signal_myself

        def signal_myself(obj, &block)
          current_actor.mailbox << obj
          receive(&block)
        end
      end
    end

    let(:receiver) { @receiver.new }
    let(:message) { Object.new }

    it "allows unconditional receive" do
      expect(receiver.signal_myself(message)).to eq(message)
    end

    it "allows arbitrary selective receive" do
      received_obj = receiver.signal_myself(message) { |o| o == message }
      expect(received_obj).to eq(message)
    end

    it "times out after the given interval", :pending => ENV['CI'] do
      interval = 0.1
      started_at = Time.now

      expect(receiver.receive(interval) { false }).to be_nil
      expect(Time.now - started_at).to be_within(Celluloid::TIMER_QUANTUM).of interval
    end
  end

  context :timers do
    before do
      @klass = Class.new do
        include included_module
        task_class task_klass

        def initialize
          @sleeping = false
          @fired = false
        end

        def do_sleep(n)
          @sleeping = true
          sleep n
          @sleeping = false
        end

        def sleeping?; @sleeping end

        def fire_after(n)
          after(n) { @fired = true }
        end

        def fire_every(n)
          @fired = 0
          every(n) { @fired += 1 }
        end

        def fired?; !!@fired end
        def fired; @fired end
      end
    end

    it "suspends execution of a method (but not the actor) for a given time" do
      actor = @klass.new

      # Sleep long enough to ensure we're actually seeing behavior when asleep
      # but not so long as to delay the test suite unnecessarily
      interval = Celluloid::TIMER_QUANTUM * 10
      started_at = Time.now

      future = actor.future(:do_sleep, interval)
      sleep(interval / 2) # wonky! :/
      expect(actor).to be_sleeping

      future.value
      expect(Time.now - started_at).to be_within(Celluloid::TIMER_QUANTUM).of interval
    end

    it "schedules timers which fire in the future" do
      actor = @klass.new

      interval = Celluloid::TIMER_QUANTUM * 10

      actor.fire_after(interval)
      expect(actor).not_to be_fired

      sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
      expect(actor).to be_fired
    end

    it "schedules recurring timers which fire in the future" do
      actor = @klass.new

      interval = Celluloid::TIMER_QUANTUM * 10

      actor.fire_every(interval)
      expect(actor.fired).to be_zero

      sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
      expect(actor.fired).to be 1

      2.times { sleep(interval + Celluloid::TIMER_QUANTUM) } # wonky! #/
      expect(actor.fired).to be 3
    end

    it "cancels timers before they fire" do
      actor = @klass.new

      interval = Celluloid::TIMER_QUANTUM * 10

      timer = actor.fire_after(interval)
      expect(actor).not_to be_fired
      timer.cancel

      sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
      expect(actor).not_to be_fired
    end

    it "allows delays from outside the actor" do
      actor = @klass.new

      interval = Celluloid::TIMER_QUANTUM * 10
      fired = false

      actor.after(interval) do
        fired = true
      end
      expect(fired).to be_falsey

      sleep(interval + Celluloid::TIMER_QUANTUM) # wonky! #/
      expect(fired).to be_truthy
    end
  end

  context :tasks do
    before do
      @klass = Class.new do
        include included_module
        task_class task_klass
        attr_reader :blocker

        def initialize
          @blocker = Blocker.new
        end

        def blocking_call
          @blocker.block
        end
      end

      class Blocker
        include Celluloid

        def block
          wait :unblock
        end

        def unblock
          signal :unblock
        end
      end
    end

    it "knows which tasks are waiting on calls to other actors" do
      actor = @klass.new

      tasks = actor.tasks
      expect(tasks.size).to be 1

      actor.future(:blocking_call)
      sleep 0.1 # hax! waiting for ^^^ call to actually start

      tasks = actor.tasks
      expect(tasks.size).to be 2

      blocking_task = tasks.find { |t| t.status != :running }
      expect(blocking_task).to be_a task_klass
      expect(blocking_task.status).to be :callwait

      actor.blocker.unblock
      sleep 0.1 # hax again :(
      expect(actor.tasks.size).to be 1
    end
  end

  context :mailbox_class do
    class ExampleMailbox < Celluloid::Mailbox; end

    subject do
      Class.new do
        include included_module
        task_class task_klass
        mailbox_class ExampleMailbox
      end
    end

    it "uses user-specified mailboxes" do
      expect(subject.new.mailbox).to be_a ExampleMailbox
    end

    it "retains custom mailboxes when subclassed" do
      subclass = Class.new(subject)
      expect(subclass.new.mailbox).to be_a ExampleMailbox
    end
  end

  context :mailbox_size do
    subject do
      Class.new do
        include included_module
        task_class task_klass
        mailbox_size 100
      end
    end

    it "configures the mailbox limit" do
      expect(subject.new.mailbox.max_size).to eq(100)
    end
  end

  context :proxy_class do
    class ExampleProxy < Celluloid::CellProxy
      def subclass_proxy?
        true
      end
    end

    subject do
      Class.new do
        include included_module
        task_class task_klass
        proxy_class ExampleProxy
      end
    end

    it "uses user-specified proxy" do
      expect{subject.new.subclass_proxy?}.to_not raise_error
    end

    it "retains custom proxy when subclassed" do
      subclass = Class.new(subject)
      expect(subclass.new.subclass_proxy?).to be(true)
    end
  end

  context :task_class do
    class ExampleTask < Celluloid::TaskFiber; end

    subject do
      Class.new do
        include included_module
        task_class ExampleTask
      end
    end

    it "overrides the task class" do
      expect(subject.new.tasks.first).to be_a ExampleTask
    end

    it "retains custom task classes when subclassed" do
      subclass = Class.new(subject)
      expect(subclass.new.tasks.first).to be_a ExampleTask
    end
  end

  context :timeouts do
    let :actor_class do
      Class.new do
        include included_module

        def name
          sleep 0.5
          :foo
        end

        def ask_name_with_timeout(other, duration)
          timeout(duration) { other.name }
        end
      end
    end

    it "allows timing out tasks, raising Celluloid::Task::TimeoutError" do
      a1 = actor_class.new
      a2 = actor_class.new

      expect { a1.ask_name_with_timeout a2, 0.3 }.to raise_error(Celluloid::Task::TimeoutError)
    end

    it "does not raise when it completes in time" do
      a1 = actor_class.new
      a2 = actor_class.new

      expect(a1.ask_name_with_timeout(a2, 0.6)).to eq(:foo)
    end
  end

  context "raw message sends" do
    it "logs on unhandled messages" do
      expect(Celluloid.logger).to receive(:debug).with("Discarded message (unhandled): first")

      actor = actor_class.new "Irma Gladden"
      actor.mailbox << :first
      sleep Celluloid::TIMER_QUANTUM
    end
  end
end