Improve test coverage.

Author: ioquatix

lib/async/scheduler.rb

@@ -102,11 +102,7 @@ def raise(*arguments)
 		end
 
 		def resume(fiber, *arguments)
-			if Fiber.scheduler
-				@selector.resume(fiber, *arguments)
-			else
-				@selector.push(fiber)
-			end
+			@selector.resume(fiber, *arguments)
 		end
 
 		# Invoked when a fiber tries to perform a blocking operation which cannot continue. A corresponding call {unblock} must be performed to allow this fiber to continue.

lib/async/task.rb

@@ -163,15 +163,15 @@ def stop(later = false)
 			if self.running?
 				if self.current?
 					if later
-						Fiber.scheduler.push Stop::Later.new(self)
+						Fiber.scheduler.push(Stop::Later.new(self))
 					else
 						raise Stop, "Stopping current task!"
 					end
 				elsif @fiber&.alive?
 					begin
 						Fiber.scheduler.raise(@fiber, Stop)
 					rescue FiberError
-						Fiber.scheduler.push Stop::Later.new(self)
+						Fiber.scheduler.push(Stop::Later.new(self))
 					end
 				end
 			else
@@ -206,17 +206,13 @@ def running?
 		# Whether we can remove this node from the reactor graph.
 		# @returns [Boolean]
 		def finished?
-			super && @status != :running
+			super && @fiber.nil?
 		end
 
 		def failed?
 			@status == :failed
 		end
 
-		def stopping?
-			@status == :stopping
-		end
-		
 		def stopped?
 			@status == :stopped
 		end

spec/async/clock_spec.rb

@@ -45,9 +45,27 @@
 		expect(subject.total).to be_within(0.02 * Q).of(0.2)
 	end
 
-	context 'with given total' do
-		subject {described_class.new(1.5)}
+	describe '#total' do
+		context 'with initial duration' do
+			let(:clock) {described_class.new(1.5)}
+			subject(:total) {clock.total}
+			
+			it{is_expected.to be == 1.5}
+		end
+		
+		it "can accumulate time" do
+			subject.start!
+			total = subject.total
+			expect(total).to be >= 0
+			sleep(0.0001)
+			expect(subject.total).to be >= total
+		end
+	end
+	
+	describe '.start' do
+		let(:clock) {described_class.start}
+		subject(:total) {clock.total}
 
-		it{is_expected.to have_attributes(total: 1.5)}
+		it {is_expected.to be >= 0.0}
 	end
 end

spec/async/node_spec.rb

@@ -22,7 +22,29 @@
 
 require 'async/node'
 
-RSpec.describe Async::Node do
+RSpec.describe Async::Children do
+	context "with no children" do
+		describe '#nil?' do
+			it {is_expected.to be_nil}
+		end
+		
+		describe '#empty?' do
+			it {is_expected.to be_empty}
+		end
+		
+		describe '#transients?' do
+			it {is_expected.to_not be_transients}
+		end
+	end
+end
+
+RSpec.describe Async::Node do	
+	describe '#children?' do
+		context "with no children" do
+			it {is_expected.to_not be_children}
+		end
+	end
+	
 	describe '#parent=' do
 		let(:child) {Async::Node.new(subject)}
 
@@ -44,6 +66,14 @@
 			expect(child.parent).to be_nil
 			expect(subject.children).to be_nil
 		end
+		
+		it "can move a child from one parent to another" do
+			another_parent = Async::Node.new
+			child.parent = another_parent
+			
+			expect(subject.children).to be_empty
+			expect(child.parent).to be == another_parent
+		end
 	end
 
 	describe '#print_hierarchy' do
@@ -152,6 +182,20 @@
 			expect(subject.children.size).to be == 2
 			expect(subject.children.each.to_a).to be == bottom
 		end
+		
+		it "deletes children that are also finished" do
+			middle = Async::Node.new(subject)
+			bottom = Async::Node.new(middle)
+			
+			allow(middle).to receive(:finished?).and_return(true)
+			allow(bottom).to receive(:finished?).and_return(true)
+			
+			middle.consume
+			
+			expect(subject.children).to be_empty
+			expect(middle.children).to be_nil
+			expect(bottom.parent).to be_nil
+		end
 	end
 
 	describe '#annotate' do

spec/async/queue_spec.rb

@@ -29,6 +29,26 @@
 require_relative 'chainable_async_examples'
 
 RSpec.shared_context Async::Queue do
+	describe '#each' do
+		it 'can enumerate queue items' do
+			reactor.async do |task|
+				10.times do |item|
+					task.sleep(0.0001)
+					subject.enqueue(item)
+				end
+				
+				subject.enqueue(nil)
+			end
+			
+			items = []
+			subject.each do |item|
+				items << item
+			end
+			
+			expect(items).to be == 10.times.to_a
+		end
+	end
+	
 	it 'should process items in order' do
 		reactor.async do |task|
 			10.times do |i|

spec/async/reactor_spec.rb

@@ -113,6 +113,8 @@
 
 				child.stop
 			end
+			
+			subject.run
 		end
 	end
 

spec/async/scheduler_spec.rb

@@ -18,19 +18,12 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'async/rspec'
 require 'async/reactor'
 require 'async/barrier'
 require 'net/http'
 
-RSpec.describe Async::Scheduler do
-	include_context Async::RSpec::Reactor
-	
-	it "can intercept sleep" do
-		expect(reactor).to receive(:kernel_sleep).with(0.001)
-		
-		sleep(0.001)
-	end
-	
+RSpec.describe Async::Scheduler do	
 	describe 'Fiber.schedule' do
 		it "can start child task" do
 			fiber = nil
@@ -44,115 +37,23 @@
 			expect(fiber).to_not be_nil
 			expect(fiber).to be_kind_of(Fiber)
 		end
-	end
-	
-	describe 'Process.wait' do
-		it "can wait on child process" do
-			expect(reactor).to receive(:process_wait).and_call_original
-			
-			pid = ::Process.spawn("true")
-			_, status = Process.wait2(pid)
-			expect(status).to be_success
-		end
-	end
-	
-	describe 'Kernel#system' do
-		it "can execute child process" do
-			# expect(reactor).to receive(:process_wait).and_call_original
-			
-			::Kernel.system("true")
-			expect($?).to be_success
-		end
-	end
-	
-	describe 'Kernel#`' do
-		it "can execute child process and capture output" do
-			expect(`echo OK`).to be == "OK\n"
-			expect($?).to be_success
-		end
-		
-		it "can execute child process with delay and capture output" do
-			expect(`sleep 1; echo OK`).to be == "OK\n"
-			expect($?).to be_success
-		end
-	end
-	
-	describe 'IO.pipe' do
-		let(:message) {"Helloooooo World!"}
 
-		it "can send message via pipe" do
-			input, output = IO.pipe
+		it "can schedule task before starting scheduler" do
+			sequence = []
 
-			reactor.async do
-				sleep(0.001)
+			thread = Thread.new do
+				scheduler = Async::Scheduler.new
 
-				message.each_char do |character|
-					output.write(character)
+				scheduler.async do
+					sequence << :running
 				end
 
-				output.close
+				Fiber.set_scheduler(scheduler)
 			end
 
-			expect(input.read).to be == message
-			
-		ensure
-			input.close
-			output.close
-		end
-		
-		it "can fetch website using Net::HTTP" do
-			barrier = Async::Barrier.new
-			events = []
-			
-			3.times do |i|
-				barrier.async do
-					events << i
-					response = Net::HTTP.get(URI "https://www.codeotaku.com/index")
-					expect(response).to_not be_nil
-					events << i
-				end
-			end
-			
-			barrier.wait
-			
-			# The requests all get started concurrently:
-			expect(events.first(3)).to be == [0, 1, 2]
-		end
-	end
-	
-	context "with thread" do
-		it "can join thread" do
-			queue = Thread::Queue.new
-			thread = Thread.new{queue.pop}
-			
-			waiting = 0
-			
-			3.times do
-				Async do
-					waiting += 1
-					thread.join
-					waiting -= 1
-				end
-			end
-			
-			expect(waiting).to be == 3
-			queue.close
-		end
-	end
-	
-	context "with queue" do
-		subject {::Thread::Queue.new}
-		let(:item) {"Hello World"}
-		
-		it "can pass items between thread and fiber" do
-			Async do
-				expect(subject.pop).to be == item
-			end
+			thread.join
 
-			::Thread.new do
-				expect(Fiber).to be_blocking
-				subject.push(item)
-			end.join
+			expect(sequence).to be == [:running]
 		end
 	end
 end