exel 1.1.0 → 1.2.0

data/spec/exel/job_spec.rb

@@ -128,15 +128,13 @@ module EXEL
 
     describe '#process' do
       let(:block) { proc {} }
+      let(:processor_class) { class_double(Class) }
 
-      before do
-        allow(Job::Parser).to receive(:parse).and_return(ast)
-      end
+      before { allow(Job::Parser).to receive(:parse).and_return(ast) }
 
       context 'without a block' do
         it 'creates a process instruction' do
-          processor_class = double(:processor_class)
-          expect(Instruction).to receive(:new).with('process', processor_class, {arg1: 'arg1_value'}, nil)
+          expect(Instruction).to receive(:new).with(processor_class, {arg1: 'arg1_value'}, nil)
 
           parser.process with: processor_class, arg1: 'arg1_value'
         end
@@ -144,19 +142,17 @@ module EXEL
         it 'appends an instruction node to the AST with no children' do
           expect(parser.ast).to receive(:add_child) do |node|
             expect(node).to be_a_kind_of(InstructionNode)
-            expect(node.instruction.name).to eq('process')
             expect(node.children).to eq([])
           end
 
-          parser.process with: double(:processor_class)
+          parser.process with: processor_class
         end
       end
 
       context 'with a block' do
         it 'passes the parsed subtree to the instruction' do
-          processor_class = double(:processor_class)
           expect(Job::Parser).to receive(:parse).with(block).and_return(ast)
-          expect(Instruction).to receive(:new).with('process', processor_class, {arg1: 'arg1_value'}, ast)
+          expect(Instruction).to receive(:new).with(processor_class, {arg1: 'arg1_value'}, ast)
 
           parser.process with: processor_class, arg1: 'arg1_value', &block
         end
@@ -164,11 +160,10 @@ module EXEL
         it 'appends an instruction node to the AST with the parsed block as its subtree' do
           expect(parser.ast).to receive(:add_child) do |node|
             expect(node).to be_a_kind_of(InstructionNode)
-            expect(node.instruction.name).to eq('process')
             expect(node.children).to eq([ast])
           end
 
-          parser.process with: double(:processor_class), &block
+          parser.process with: processor_class, &block
         end
       end
     end
@@ -184,7 +179,7 @@ module EXEL
         end
 
         it "creates a #{data[:method]} instruction" do
-          expect(Instruction).to receive(:new).with(data[:method].to_s, data[:processor], {arg1: 'arg1_value'}, ast)
+          expect(Instruction).to receive(:new).with(data[:processor], {arg1: 'arg1_value'}, ast)
           parser.send(data[:method], arg1: 'arg1_value') {}
         end
 
@@ -198,7 +193,6 @@ module EXEL
         it 'adds parsed subtree and instruction to the AST' do
           expect(parser.ast).to receive(:add_child) do |node|
             expect(node).to be_a_kind_of(InstructionNode)
-            expect(node.instruction.name).to eq(data[:method].to_s)
             expect(node.children).to eq([ast])
           end
 
@@ -212,5 +206,21 @@ module EXEL
         expect(parser.context).to be_a_kind_of(DeferredContextValue)
       end
     end
+
+    describe '#listen' do
+      let(:listener_class) { class_double(Class) }
+
+      it 'creates a listen instruction' do
+        expect(ListenInstruction).to receive(:new).with(:event, listener_class)
+        parser.listen for: :event, with: listener_class
+      end
+
+      it 'adds an InstructionNode containing the listen instruction' do
+        parser.listen for: :event, with: listener_class
+        node = parser.ast.children.first
+        expect(node).to be_a_kind_of(InstructionNode)
+        expect(node.instruction).to be_a_kind_of(ListenInstruction)
+      end
+    end
   end
 end

data/spec/exel/listen_instruction_spec.rb

@@ -0,0 +1,14 @@
+module EXEL
+  describe ListenInstruction do
+    subject(:instruction) { EXEL::ListenInstruction.new(:event, listener) }
+    let(:listener) { double(:listener) }
+    let(:context) { EXEL::Context.new }
+
+    describe '#execute' do
+      it 'registers the event listener' do
+        expect(instruction).to receive(:register_listener).with(context, :event, listener)
+        instruction.execute(context)
+      end
+    end
+  end
+end

data/spec/exel/logging_spec.rb

@@ -4,13 +4,13 @@ module EXEL
     after { Logging.logger = @restore_logger }
 
     describe '.logger=' do
-      it 'should set a logger' do
+      it 'sets a logger' do
         logger = double(:logger)
         Logging.logger = logger
         expect(Logging.logger).to be(logger)
       end
 
-      it 'should set a null logger when nil given' do
+      it 'sets a null logger when nil given' do
         expect(Logger).to receive(:new).with('/dev/null')
         Logging.logger = nil
       end
@@ -19,7 +19,7 @@ module EXEL
     describe '.logger' do
       before { Logging.instance_variable_set(:@logger, nil) }
 
-      it 'should initialize the logger on first read if not already set' do
+      it 'initializes the logger on first read if not already set' do
         EXEL.configure do |config|
           config.log_level = :warn
           config.log_filename = 'log.txt'

data/spec/exel/processors/split_processor_spec.rb

@@ -15,7 +15,7 @@ module EXEL
       describe '#process' do
         let(:file) { create_file(3) }
 
-        it 'should process file with 3 lines line by line' do
+        it 'processes file with 3 lines line by line' do
           allow(CSV).to receive(:foreach).and_yield('line0').and_yield('line1').and_yield('line2')
 
           3.times do |i|
@@ -28,12 +28,20 @@ module EXEL
           splitter.process(callback)
         end
 
-        it 'should abort parsing the csv file if it is malformed' do
+        it 'aborts parsing the csv file if it is malformed' do
           allow(CSV).to receive(:foreach).and_raise(CSV::MalformedCSVError)
           expect(splitter).to receive(:process_line).with(:eof, callback)
 
           splitter.process(callback)
         end
+
+        it 'does not delete the resource file if :delete_resource is set to false in the context' do
+          allow(CSV).to receive(:foreach).and_yield(:eof)
+          expect(File).not_to receive(:delete).with(file.path)
+
+          context[:delete_resource] = false
+          splitter.process(callback)
+        end
       end
 
       describe '#process_line' do
@@ -42,8 +50,8 @@ module EXEL
           {input: 3, chunks: %W(0\n1\n 2\n)},
           {input: 4, chunks: %W(0\n1\n 2\n3\n)}
         ].each do |data|
-          it "should produce #{data[:chunks].size} chunks with #{data[:input]} input lines" do
-            allow(splitter).to receive(:chunk_size).and_return(2)
+          it "produces #{data[:chunks].size} chunks with #{data[:input]} input lines" do
+            context[:chunk_size] = 2
 
             data[:chunks].each do |chunk|
               expect(splitter).to receive(:generate_chunk).with(chunk).and_return(chunk_file)
@@ -59,13 +67,13 @@ module EXEL
       end
 
       describe '#generate_chunk' do
-        it 'should create a file with the contents of the given string' do
+        it 'creates a file with the contents of the given string' do
           file = splitter.generate_chunk('abc')
           content = file.read
           expect(content).to eq('abc')
         end
 
-        it 'should create a file with a unique name' do
+        it 'creates a file with a unique name' do
           3.times do |i|
             file = splitter.generate_chunk('content')
             expect(file.path).to include("text_#{i + 1}_")

data/spec/exel/sequence_node_spec.rb

@@ -6,7 +6,7 @@ module EXEL
     it { is_expected.to be_an(ASTNode) }
 
     describe '#run' do
-      it 'should run each child node in sequence' do
+      it 'runs each child node in sequence' do
         expect(node.children.first).to receive(:run).with(context).once.ordered
         expect(node.children.last).to receive(:run).with(context).once.ordered
 

data/spec/exel_spec.rb

@@ -38,4 +38,11 @@ describe EXEL do
       end
     end
   end
+
+  after :each do
+    EXEL.configure do |config|
+      config.remote_provider = nil # reset providers to default
+      config.async_provider = nil
+    end
+  end
 end