Tidy up tests.

Author: ioquatix

lib/async/job/processor/inline.rb

@@ -23,8 +23,14 @@ def initialize(delegate, parent: nil)
 					super(delegate)
 
 					@parent = parent || Async::Idler.new
+					
+					@call_count = 0
+					@complete_count = 0
 				end
 
+				# @attribute [Integer] The count of completed jobs.
+				attr_reader :complete_count
+				
 				# Process a job asynchronously with optional scheduling.
 				# If the job has a scheduled_at time, the processor will wait until that time before execution.
 				# @parameter job [Hash] The job data containing execution details.
@@ -36,7 +42,9 @@ def call(job)
 							sleep(scheduled_at - Time.now)
 						end
 
+						@call_count += 1
 						@delegate.call(job)
+						@complete_count += 1
 					rescue => error
 						Console.error(self, error)
 					end
@@ -51,6 +59,13 @@ def start
 				def stop
 					@delegate.stop
 				end
+				
+				# Returns statistics about the processor's job counts.
+				#
+				# - `c`: call count / completed count.
+				def statistics
+					{c: [@call_count, @complete_count]}
+				end
 			end
 		end
 	end

test/async/job/processor/aggregate.rb

@@ -46,9 +46,6 @@ def call(job)
 		processor.call(:job1)
 		processor.call(:job2)
 
-		# Give the processor a chance to process jobs
-		sleep(0.1)
-		
 		expect(delegate.called_jobs).to be(:include?, :job1)
 		expect(delegate.called_jobs).to be(:include?, :job2)
 	end
@@ -58,8 +55,6 @@ def call(job)
 
 		error_processor = subject.new(error_delegate)
 		error_processor.call(:job1)
-		# Give the processor a chance to process jobs and handle error
-		sleep(0.1)
 
 		# Assert that the error was logged
 		expect_console.to have_logged(

test/async/job/processor/inline.rb

@@ -49,35 +49,15 @@ def call(job)
 		job = {id: 1, data: "test"}
 		processor.call(job)
 
-		# Wait a bit for async processing
-		sleep(0.1)
-		
 		expect(delegate.called).to be == true
 		expect(delegate.job).to be == job
 	end
 
-	it "handles scheduled jobs" do
+	it "handles scheduled jobs" do	
 		scheduled_time = Time.now + 0.05
 		job = {id: 1, scheduled_at: scheduled_time}
 
 		start_time = Time.now
-		processor.call(job)
-		
-		# Wait for processing to complete
-		sleep(0.1)
-		
-		expect(delegate.called).to be == true
-		# The job should have been delayed by at least 0.05 seconds
-		expect(Time.now - start_time).to be >= 0.05
-	end
-	
-	it "calls sleep for scheduled jobs" do
-		scheduled_time = Time.now + 0.1
-		job = {id: 1, "scheduled_at" => scheduled_time}
-		
-		# Mock the sleep method to ensure it's called
-		expect(processor).to receive(:sleep).and_return(nil)
-		
 		processor.call(job).wait
 
 		expect(delegate.called).to be == true
@@ -92,9 +72,6 @@ def call(job)
 		# Should not raise exception
 		expect{error_processor.call(job)}.not.to raise_exception
 
-		# Wait for async processing
-		sleep(0.1)
-		
 		# Assert that the error was logged
 		expect_console.to have_logged(
 			severity: be == :error,
@@ -113,4 +90,16 @@ def call(job)
 		expect(delegate.stopped).to be == true
 		expect(result).to be == "stopped"
 	end
+	
+	with "#statistics" do
+		it "returns statistics with call and complete counts" do
+			expect(processor.statistics).to be == {c: [0, 0]}
+			
+			# Call the processor to increment counts
+			job = {id: 1, data: "test"}
+			processor.call(job)
+			
+			expect(processor.statistics).to be == {c: [1, 1]}
+		end
+	end
 end