te3270 0.7.1 → 0.8.0

data/spec/lib/te3270/emulators/quick3270_spec.rb

@@ -1,170 +1,177 @@
-if Gem.win_platform?
+require 'spec_helper'
 
-  require 'spec_helper'
+describe TE3270::Emulators::Quick3270 do
 
-  describe TE3270::Emulators::Quick3270 do
+  unless Gem.win_platform?
+    class WIN32OLE
+    end
+  end
 
-    let(:quick) { TE3270::Emulators::Quick3270.new }
+  let(:quick) { TE3270::Emulators::Quick3270.new }
+
+  before(:each) do
+    allow(WIN32OLE).to receive(:new).and_return quick_system
+    quick.instance_variable_set(:@session_file, 'the_host')
+  end
 
-    before(:each) do
-      WIN32OLE.stub(:new).and_return quick_system
-      quick.instance_variable_set(:@session_file, 'the_host')
+  describe "global behaviors" do
+    it 'should start new terminal' do
+      expect(WIN32OLE).to receive(:new).and_return(quick_system)
+      quick.connect
     end
 
-    describe "global behaviors" do
-      it 'should start new terminal' do
-        WIN32OLE.should_receive(:new).and_return(quick_system)
-        quick.connect
-      end
+    it 'should establish a session' do
+      allow(quick_system).to receive(:ActiveSession).and_return(quick_session)
+      quick.connect
+    end
 
-      it 'should establish a session' do
-        quick_system.should_receive(:ActiveSession).and_return(quick_session)
-        quick.connect
-      end
+    it 'should get the screen from the active session' do
+      expect(quick_session).to receive(:Screen).and_return(quick_screen)
+      quick.connect
+    end
 
-      it 'should get the screen from the active session' do
-        quick_session.should_receive(:Screen).and_return(quick_screen)
-        quick.connect
+    it 'should take the Visible value from a block' do
+      expect(quick_system).to receive(:Visible=).with(false)
+      quick.connect do |platform|
+        platform.visible = false
       end
+    end
 
-      it 'should take the Visible value from a block' do
-        quick_system.should_receive(:Visible=).with(false)
-        quick.connect do |platform|
-          platform.visible = false
-        end
+    it 'should take the session file from a block' do
+      expect(quick).to receive(:session_file=).with('blah.txt')
+      quick.connect do |platform|
+        platform.session_file = 'blah.txt'
       end
+    end
 
-      it 'should take the session file from a block' do
-        quick.should_receive(:session_file=).with('blah.txt')
-        quick.connect do |platform|
-          platform.session_file = 'blah.txt'
-        end
-      end
+    it 'should display an error when the session file is not set' do
+      quick.instance_variable_set(:@session_file, nil)
+      expect { quick.connect }.to raise_error('The session file must be set in a block when calling connect with the Quick3270 emulator.')
+    end
 
-      it 'should display an error when the session file is not set' do
-        quick.instance_variable_set(:@session_file, nil)
-        expect { quick.connect }.to raise_error('The session file must be set in a block when calling connect with the Quick3270 emulator.')
+    it 'should open the connection using the sesion file' do
+      expect(quick_session).to receive(:Open).with('blah.txt')
+      quick.connect do |platform|
+        platform.session_file = 'blah.txt'
       end
+    end
 
-      it 'should open the connection using the sesion file' do
-        quick_session.should_receive(:Open).with('blah.txt')
-        quick.connect do |platform|
-          platform.session_file = 'blah.txt'
-        end
-      end
+    it 'should default to Visible being true when not provided' do
+      expect(quick_system).to receive(:Visible=).with(true)
+      quick.connect
+    end
 
-      it 'should default to Visible being true when not provided' do
-        quick_system.should_receive(:Visible=).with(true)
-        quick.connect
-      end
+    it 'should make the connection via the session' do
+      expect(quick_session).to receive(:Connect)
+      quick.connect
+    end
 
-      it 'should make the connection via the session' do
-        quick_session.should_receive(:Connect)
-        quick.connect
-      end
+    it 'should check to make sure the connection is successful before continuing' do
+      expect(quick_session).to receive(:Connected).once.and_return(false)
+      expect(quick_screen).to receive(:WaitHostQuiet).once.with(1000)
+      expect(quick_session).to receive(:Connected).once.and_return(true)
+      quick.connect
+    end
 
-      it 'should check to make sure the connection is successful before continuing' do
-        quick_session.should_receive(:Connected).once.and_return(false)
-        quick_screen.should_receive(:WaitHostQuiet).once.with(1000)
-        quick_session.should_receive(:Connected).once.and_return(true)
-        quick.connect
-      end
+    it 'should disconnect from a session' do
+      application = double('application')
+      expect(quick_session).to receive(:Disconnect)
+      expect(quick_system).to receive(:Application).and_return(application)
+      expect(application).to receive(:Quit)
+      quick.connect
+      quick.disconnect
+    end
+  end
 
-      it 'should disconnect from a session' do
-        application = double('application')
-        quick_session.should_receive(:Disconnect)
-        quick_system.should_receive(:Application).and_return(application)
-        application.should_receive(:Quit)
-        quick.connect
-        quick.disconnect
-      end
+  describe "interacting with text fields" do
+    it 'should get the value from the screen' do
+      expect(quick_screen).to receive(:GetString).with(1, 2, 7).and_return('blah')
+      quick.connect
+      expect(quick.get_string(1, 2, 7)).to eql 'blah'
     end
 
-    describe "interacting with text fields" do
-      it 'should get the value from the screen' do
-        quick_screen.should_receive(:GetString).with(1, 2, 7).and_return('blah')
-        quick.connect
-        quick.get_string(1, 2, 7).should == 'blah'
-      end
+    it 'should put a value on the screen' do
+      expect(quick_screen).to receive(:MoveTo).with(15, 56)
+      expect(quick_screen).to receive(:PutString).with('blah')
+      expect(quick_screen).to receive(:WaitHostQuiet).with(3000)
+      quick.connect
+      quick.put_string('blah', 15, 56)
+    end
+  end
 
-      it 'should put a value on the screen' do
-        quick_screen.should_receive(:MoveTo).with(15, 56)
-        quick_screen.should_receive(:PutString).with('blah')
-        quick_screen.should_receive(:WaitHostQuiet).with(3000)
-        quick.connect
-        quick.put_string('blah', 15, 56)
-      end
+  describe "interacting with the screen" do
+    it 'should know how to send function keys' do
+      expect(quick_screen).to receive(:SendKeys).with('<Home>')
+      expect(quick_screen).to receive(:WaitHostQuiet).with(3000)
+      quick.connect
+      quick.send_keys(TE3270.Home)
     end
 
-    describe "interacting with the screen" do
-      it 'should know how to send function keys' do
-        quick_screen.should_receive(:SendKeys).with('<Home>')
-        quick_screen.should_receive(:WaitHostQuiet).with(3000)
-        quick.connect
-        quick.send_keys(TE3270.Home)
-      end
+    it 'should wait for a string to appear' do
+      expect(quick_screen).to receive(:WaitForString).with('string', 3, 10)
+      quick.connect
+      quick.wait_for_string('string', 3, 10)
+    end
 
-      it 'should wait for a string to appear' do
-        quick_screen.should_receive(:WaitForString).with('string', 3, 10)
-        quick.connect
-        quick.wait_for_string('string', 3, 10)
-      end
+    it 'should wait for the host to be quiet' do
+      expect(quick_screen).to receive(:WaitHostQuiet).with(6000)
+      quick.connect
+      quick.wait_for_host(6)
+    end
 
-      it 'should wait for the host to be quiet' do
-        quick_screen.should_receive(:WaitHostQuiet).with(6000)
-        quick.connect
-        quick.wait_for_host(6)
-      end
+    it 'should wait until the cursor is at a position' do
+      expect(quick_screen).to receive(:WaitForCursor).with(5, 8)
+      quick.connect
+      quick.wait_until_cursor_at(5, 8)
+    end
 
-      it 'should wait until the cursor is at a position' do
-        quick_screen.should_receive(:WaitForCursor).with(5, 8)
-        quick.connect
-        quick.wait_until_cursor_at(5,8)
-      end
+    if Gem.win_platform?
 
       it 'should take screenshots' do
         take = double('Take')
-        quick_system.should_receive(:WindowTitle).and_return('The Title')
-        Win32::Screenshot::Take.should_receive(:of).with(:window, title: 'The Title').and_return(take)
-        take.should_receive(:write).with('image.png')
+        expect(quick_system).to receive(:WindowTitle).and_return('The Title')
+        expect(Win32::Screenshot::Take).to receive(:of).with(:window, title: 'The Title').and_return(take)
+        expect(take).to receive(:write).with('image.png')
         quick.connect
         quick.screenshot('image.png')
       end
 
       it 'should delete the file for the screenshot if it already exists' do
-        File.should_receive(:exists?).and_return(true)
-        File.should_receive(:delete)
+        expect(File).to receive(:exists?).and_return(true)
+        expect(File).to receive(:delete)
         take = double('Take')
-        quick_system.should_receive(:WindowTitle).and_return('The Title')
-        Win32::Screenshot::Take.should_receive(:of).with(:window, title: 'The Title').and_return(take)
-        take.should_receive(:write).with('image.png')
+        expect(quick_system).to receive(:WindowTitle).and_return('The Title')
+        expect(Win32::Screenshot::Take).to receive(:of).with(:window, title: 'The Title').and_return(take)
+        expect(take).to receive(:write).with('image.png')
         quick.connect
         quick.screenshot('image.png')
       end
 
       it 'should make the window visible before taking a screenshot' do
         take = double('Take')
-        quick_system.should_receive(:WindowTitle).and_return('The Title')
-        Win32::Screenshot::Take.should_receive(:of).with(:window, title: 'The Title').and_return(take)
-        take.should_receive(:write).with('image.png')
-        quick_system.should_receive(:Visible=).once.with(true)
-        quick_system.should_receive(:Visible=).twice.with(false)
+        expect(quick_system).to receive(:WindowTitle).and_return('The Title')
+        expect(Win32::Screenshot::Take).to receive(:of).with(:window, title: 'The Title').and_return(take)
+        expect(take).to receive(:write).with('image.png')
+        expect(quick_system).to receive(:Visible=).once.with(true)
+        expect(quick_system).to receive(:Visible=).twice.with(false)
         quick.connect do |emulator|
           emulator.visible = false
         end
         quick.screenshot('image.png')
       end
 
-      it 'should get the screen text' do
-        quick_screen.should_receive(:Rows).and_return(3)
-        quick_screen.should_receive(:Cols).and_return(10)
-        3.times do |time|
-          quick_screen.should_receive(:GetString).with(time+1, 1, 10).and_return("row #{time}")
-        end
-        quick.connect
-        quick.text.should == 'row 0\nrow 1\nrow 2\n'
+    end
+
+    it 'should get the screen text' do
+      expect(quick_screen).to receive(:Rows).and_return(3)
+      expect(quick_screen).to receive(:Cols).and_return(10)
+      3.times do |time|
+        expect(quick_screen).to receive(:GetString).with(time+1, 1, 10).and_return("row #{time}")
       end
+      quick.connect
+      expect(quick.text).to eql 'row 0\nrow 1\nrow 2\n'
     end
   end
-
 end
+
+

data/spec/lib/te3270/emulators/x3270_spec.rb

@@ -6,43 +6,43 @@ describe TE3270::Emulators::X3270 do
 
   before(:each) do
     @x3270_io = double('x3270_io')
-    Open3.stub(:popen2e).and_return [@x3270_io,@x3270_io,nil]
+    allow(Open3).to receive(:popen2e).and_return [@x3270_io,@x3270_io,nil]
     x3270.instance_variable_set(:@executable_command, "the_command")
     x3270.instance_variable_set(:@host, "the_host")
-    @x3270_io.stub(:print)
-    @x3270_io.stub(:flush)
-    @x3270_io.stub(:gets).and_return('goo','ok')
+    allow(@x3270_io).to receive(:print)
+    allow(@x3270_io).to receive(:flush)
+    allow(@x3270_io).to receive(:gets).and_return('goo','ok')
     end
 
   describe "global behaviors" do
     it 'should open pipe to x3270' do
-      Open3.should_receive(:popen2e).and_return(x3270_system)
+      expect(Open3).to receive(:popen2e).and_return(x3270_system)
       x3270.connect
     end
    
     it 'should take the timeout value from a block' do
-      x3270.should_receive(:executable_command=).with('path to the x3270 executable')
+      expect(x3270).to receive(:executable_command=).with('path to the x3270 executable')
       x3270.connect do |platform|
         platform.executable_command = 'path to the x3270 executable'
       end
     end
 
     it 'should take the host to connect to from a block' do
-      x3270.should_receive(:host=).with('name of host to connect to')
+      expect(x3270).to receive(:host=).with('name of host to connect to')
       x3270.connect do |platform|
         platform.host = 'name of host to connect to'
       end
     end
 
     it 'should take the max timeout value from a block' do
-      x3270.should_receive(:max_wait_time=).with(42)
+      expect(x3270).to receive(:max_wait_time=).with(42)
       x3270.connect do |platform|
         platform.max_wait_time = 42
       end
     end
 
     it 'should take the connection port from a block' do
-      x3270.should_receive(:port=).with(3270)
+      expect(x3270).to receive(:port=).with(3270)
       x3270.connect do |platform|
         platform.port = 3270
       end
@@ -59,25 +59,24 @@ describe TE3270::Emulators::X3270 do
     end
 
     it 'should default to max_wait_time being 10 when not provided' do
-      #x3270.should_receive(:max_wait_time=).with(10)
       x3270.connect
-      x3270.instance_variable_get(:@max_wait_time).should eq(10)
+      expect(x3270.instance_variable_get(:@max_wait_time)).to eql(10)
     end
 
     it 'should default to port being 23 when not provided' do
       x3270.connect
-      x3270.instance_variable_get(:@port).should eq(23)
+      expect(x3270.instance_variable_get(:@port)).to eql(23)
     end
 
     it 'should display an error when cannot popen supplied x3270 program' do
-      Open3.stub(:popen2e).and_raise('darn it, popen failed')
+      allow(Open3).to receive(:popen2e).and_raise('darn it, popen failed')
       expect { x3270.connect }.to raise_error( "Could not start x3270 'the_command': darn it, popen failed")
     end
 
     it 'should close input and output on pipe when disconnect called' do
       io = double('IO')
-      Open3.stub(:popen2e).and_return([io,io,io])
-      io.should_receive(:close).twice
+      expect(Open3).to receive(:popen2e).and_return [io,io,io]
+      allow(io).to receive(:close).twice
       x3270.connect
       x3270.disconnect
     end
@@ -85,23 +84,22 @@ describe TE3270::Emulators::X3270 do
 
   describe "interacting with text fields" do
     it 'should get the value from the screen' do
-      @x3270_io.should_receive(:print).with("ascii(0,1,7)\n")
-      @x3270_io.stub(:gets).and_return('data: blah','goo','ok')
-      #@x3270_io.stub(:gets).and_return('ok')
+      expect(@x3270_io).to receive(:print).with("ascii(0,1,7)\n")
+      expect(@x3270_io).to receive(:gets).and_return('data: blah','goo','ok')
       x3270.connect
-      x3270.get_string(1, 2, 7).should == 'blah'
+      expect(x3270.get_string(1, 2, 7)).to eql 'blah'
     end
 
     it 'should put a value on the screen' do
-      @x3270_io.should_receive(:print).with("MoveCursor(14,55)\n")
-      @x3270_io.should_receive(:print).with('string "blah"'+"\n")
+      expect(@x3270_io).to receive(:print).with("MoveCursor(14,55)\n")
+      expect(@x3270_io).to receive(:print).with('string "blah"'+"\n")
       x3270.connect
       x3270.put_string('blah', 15, 56)
     end
 
     it 'should put proper escape value on the screen' do
-      @x3270_io.should_receive(:print).with("MoveCursor(14,55)\n")
-      @x3270_io.should_receive(:print).with('string "ab\"cd"'+"\n")
+      expect(@x3270_io).to receive(:print).with("MoveCursor(14,55)\n")
+      expect(@x3270_io).to receive(:print).with('string "ab\"cd"'+"\n")
       x3270.connect
       x3270.put_string('ab"cd', 15, 56)
     end
@@ -109,83 +107,83 @@ describe TE3270::Emulators::X3270 do
 
   describe "interacting with the screen" do
     it 'should know how to send function keys' do
-      @x3270_io.should_receive(:print).with("Home\n")
-      @x3270_io.should_receive(:print).with("wait(output)\n")
+      expect(@x3270_io).to receive(:print).with("Home\n")
+      expect(@x3270_io).to receive(:print).with("wait(output)\n")
       x3270.connect
       x3270.send_keys(TE3270.Home)
     end
 
     it 'should know how to send program function keys ' do
-      @x3270_io.should_receive(:print).with("Pf(13)\n")
-      @x3270_io.should_receive(:print).with("wait(output)\n")
+      expect(@x3270_io).to receive(:print).with("Pf(13)\n")
+      expect(@x3270_io).to receive(:print).with("wait(output)\n")
       x3270.connect
       x3270.send_keys(TE3270.Pf13)
     end
 
     it 'should know how to send program attention keys ' do
-      @x3270_io.should_receive(:print).with("Pa(2)\n")
-      @x3270_io.should_receive(:print).with("wait(output)\n")
+      expect(@x3270_io).to receive(:print).with("Pa(2)\n")
+      expect(@x3270_io).to receive(:print).with("wait(output)\n")
       x3270.connect
       x3270.send_keys(TE3270.Pa2)
     end
 
     it 'should wait for a string to appear' do
-      @x3270_io.should_receive(:print).with("ascii(2,9,6)\n")
-      @x3270_io.should_receive(:gets).and_return('data: string','goo','ok')
-      x3270.should_not_receive(:sleep)
+      expect(@x3270_io).to receive(:print).with("ascii(2,9,6)\n")
+      expect(@x3270_io).to receive(:gets).and_return('data: string','goo','ok')
+      expect(x3270).not_to receive(:sleep)
       x3270.connect
       x3270.wait_for_string('string', 3, 10)
     end
 
     it 'should timeout when wait for a string does not appear' do
-      @x3270_io.should_receive(:print).with("ascii(2,9,6)\n").exactly(20).times
-      @x3270_io.should_receive(:gets).and_return('data: stuff','goo','ok')
-      x3270.should_receive(:sleep).exactly(20).times
+      expect(@x3270_io).to receive(:print).with("ascii(2,9,6)\n").exactly(20).times
+      expect(@x3270_io).to receive(:gets).and_return('data: stuff','goo','ok')
+      expect(x3270).to receive(:sleep).exactly(20).times
       x3270.connect
       x3270.wait_for_string('string', 3, 10)
     end
 
     it 'should find string after one sleep when waiting for a string to appear' do
-      @x3270_io.should_receive(:print).with("ascii(2,9,6)\n").twice
-      @x3270_io.should_receive(:gets).and_return('data: blah','goo','ok','data: string','goo','ok')
-      x3270.stub(:sleep).with(0.5).once
+      expect(@x3270_io).to receive(:print).with("ascii(2,9,6)\n").twice
+      expect(@x3270_io).to receive(:gets).and_return('data: blah','goo','ok','data: string','goo','ok')
+      expect(x3270).to receive(:sleep).with(0.5).once
       x3270.connect
       x3270.wait_for_string('string', 3, 10)
     end
 
     it 'should wait for host' do
-      @x3270_io.should_receive(:print).with("Wait(10,Output)\n")
+      expect(@x3270_io).to receive(:print).with("Wait(10,Output)\n")
       x3270.connect
       x3270.wait_for_host(10)
     end
 
     it 'should wait until the cursor is at a position' do
-      @x3270_io.should_receive(:print).with("MoveCursor(5,8)\n")
+      expect(@x3270_io).to receive(:print).with("MoveCursor(5,8)\n")
       x3270.connect
       x3270.wait_until_cursor_at(6,9)
     end
 
     it 'should take screenshots' do
-      File.should_receive(:exists?).and_return(false)
-      File.should_not_receive(:delete)
-      @x3270_io.should_receive(:print).with("printtext(file,image.txt)\n")
+      expect(File).to receive(:exists?).and_return(false)
+      expect(File).not_to receive(:delete)
+      expect(@x3270_io).to receive(:print).with("printtext(file,image.txt)\n")
       x3270.connect
       x3270.screenshot("image.txt")
     end
 
     it 'should delete existing file when taking screenshots' do
-      File.should_receive(:exists?).and_return(true)
-      File.should_receive(:delete)
-      @x3270_io.should_receive(:print).with("printtext(file,image.txt)\n")
+      expect(File).to receive(:exists?).and_return(true)
+      expect(File).to receive(:delete)
+      expect(@x3270_io).to receive(:print).with("printtext(file,image.txt)\n")
       x3270.connect
       x3270.screenshot("image.txt")
     end
 
     it 'should get all text from screen' do
-      @x3270_io.should_receive(:print).with("ascii(0,0,1920)\n")
-      @x3270_io.should_receive(:gets).and_return('data: string','goo','ok')
+      expect(@x3270_io).to receive(:print).with("ascii(0,0,1920)\n")
+      expect(@x3270_io).to receive(:gets).and_return('data: string','goo','ok')
       x3270.connect
-      x3270.text.should == 'string'
+      expect(x3270.text).to eql 'string'
     end
   end
 end