te3270 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af8cc879e8470d05f34abc4ad47a7b6db9c173a1
-  data.tar.gz: eb94d218b98a0d9d9cfc26ee4d8c147fb7ea18ea
+  metadata.gz: 3a98a2c51a06119ab5ff8660994f1cbf352356d9
+  data.tar.gz: dd0cc3dda81267b7408b80e745b3de6adf7ecb78
 SHA512:
-  metadata.gz: 03d8a5fc9df38d7efd38a949f4905ecc34b3fb34410ee6bdc9a4ee12ecc041fb98233c4aaaa34707f6473f2b76ff2960a76f1aa8e5e782b6067b7ea3edbca176
-  data.tar.gz: 19755164422327c56e5b1bce336ca524007c772343efaf499e67230650652caa18a52948056e692b6460634bea7942e7b68e691f12f974a6ce4fe3fa5ef89fd0
+  metadata.gz: d019afdd33a9b46215f887c3983bce5bb86911e5fb2ceb5c1fabcfb97f683028117da4321aaf91bbd110683c8ad35512b64bce79a6d68f4cfe7b46e6b2cd3b1e
+  data.tar.gz: 4638275f200b51447eab85aa35b859a23a445a6fc3501485f4cb94572811f09e29f988515b32e5f8774c5b2329c7e7ec6678456791d90b8809b71163202e4441

data/ChangeLog

@@ -1,3 +1,7 @@
+=== Version 0.8.0 / 2016-11-22 (Thanks David West)
+* Enhancements
+ * Added support for Virtel driver
+
 === Version 0.7.1 / 2016/7/5
 * Enhanced the native portion of installation by added messages and warnings
 

data/Gemfile

@@ -1,8 +1,7 @@
-source 'https://rubygems.org'
+source 'http://rubygems.org'
 
 require 'rbconfig'
 
-gem 'rake'
 gem 'fuubar'
 gem 'guard-rspec'
 gem 'wdm', '>= 0.1.0'

data/README.md

@@ -3,9 +3,9 @@
 This gem can be used to drive a 3270 terminal emulator.  You have to have a supported emulator installed on the
 machines on which you use the gem.  Currently the supported emulators are
 [EXTRA! X-treme](http://www.attachmate.com/Products/Terminal+Emulation/Extra/xtreme/extra-x-treme.htm) by
-Attachmate, [Quick3270](http://www.dn-computing.com/Quick3270.htm) by DN-Computing,
+Attachmate, [Quick3270](http://www.dn-computing.com/Quick3270.htm) by DN-Computing, [Virtel Web Access](http://www.virtelweb.com/solutions/3270-terminal-emulation.html),
 and [X3270](http://x3270.bgp.nu/).
-The first two are commercial products and need to be purchased.
+The first three are commercial products and need to be purchased.
 X3270 is open source. Support for other
 emulators will be added as time permits.
 

data/lib/te3270.rb

@@ -7,8 +7,9 @@ require 'te3270/emulator_factory'
 
 #
 # This gem can be used to drive a 3270 terminal emulator.  You have to have a supported emulator installed on the
-# machines on which you use the gem.  Currently the only supported emulators are EXTRA! X-treme by Attachmate and
-# Quick3270 by DN-Computing.  These are commercial products and you will need to purchase one of them in order to
+# machines on which you use the gem.  Currently the supported emulators are EXTRA! X-treme by Attachmate,
+# Quick3270 by DN-Computing, Virtel Web Access and X3270.  These are commercial products, with the exception of X3270,
+# and you will need to purchase one of them in order to
 # use this gem.  We do plan to support other emulators as time permits.
 #
 # This gem has been designed to work very similar to the page-object gem.  You will use it to create screen objects
@@ -65,7 +66,8 @@ module TE3270
   # To know what information you should provide in the block please see the classes in
   # the TE3270::Emulators package.
   #
-  #@param platform =[:extra,:quick3270] use :extra for Extra emulator and :quick3270 for quick emulator
+  #@param platform =[:extra,:quick3270, :virtel] use :extra for Extra emulator, :quick3270 for quick emulator, :virtel
+  #for Virtel Web access, and :x3270 for X3270
   #
   def self.emulator_for(platform, &block)
     platform_class = TE3270::EmulatorFactory.emulator_for(platform)

data/lib/te3270/emulator_factory.rb

@@ -1,6 +1,7 @@
 require 'te3270/emulators/extra'
 require 'te3270/emulators/quick3270'
 require 'te3270/emulators/x3270'
+require 'te3270/emulators/virtel'
 
 module TE3270
   #
@@ -12,7 +13,8 @@ module TE3270
     EMULATORS = {
         extra: TE3270::Emulators::Extra,
         quick3270: TE3270::Emulators::Quick3270,
-        x3270: TE3270::Emulators::X3270
+        x3270: TE3270::Emulators::X3270,
+        virtel: TE3270::Emulators::Virtel
     }
 
     def self.emulator_for(platform)

data/lib/te3270/emulators/virtel.rb

@@ -0,0 +1,210 @@
+module TE3270
+  module Emulators
+    #
+    # This class has the code necessary to communicate with the terminal emulator called Virtel.
+    # It is a browser based terminal emulator. Watir webdriver (chrome only) is used to drive a browser with VWS (Virtel Web Access)
+    # You can use this emulator by providing the +:virtel+ parameter to the constructor of your screen
+    # object or by passing the same value to the +emulator_for+ method on the +TE3270+ module.
+    #
+    class Virtel
+
+      attr_writer :url, :max_wait_time
+      WAIT_SLEEP_INTERVAL = 0.2 # How long should we sleep during the wait loop.
+
+      def initialize
+        require 'watir-webdriver'
+      end
+
+      #
+      # Creates a method to connect to Virtel System. This method expects a block in which certain
+      # platform specific values can be set.  Extra can take the following parameters.
+      #
+      # * url - this value is required and should be the url of the session.
+      # * max_wait_time - max time to wait in wait_for_string (defaults to 10 if not specified)
+      #
+      # @example Example calling screen object constructor with a block
+      #   screen_object = MyScreenObject.new(:virtel)
+      #   screen_object.connect do |emulator|
+      #     emulator.url = 'http://mainframe:41001/w2h/WEB2AJAX.htm+Sessmgr'
+      #   end
+      #
+      def connect
+        @max_wait_time = 10
+        yield self if block_given?
+        start_virtel_browser
+
+        raise 'The url must be set in a block when calling connect with the Virtel emulator.' if @url.nil?
+      end
+
+      #
+      # Disconnects the Virtel System connection
+      #
+      def disconnect
+        @browser.close
+      end
+
+      #
+      # Extracts text of specified length from a start point.
+      #
+      # @param [Fixnum] row the x coordinate of location on the screen.
+      # @param [Fixnum] column the y coordinate of location on the screen.
+      # @param [Fixnum] length the length of string to extract
+      # @return [String]
+      #
+      def get_string(row, column, length)
+        @browser.execute_script <<-JS
+          return VIR3270.getBoxedText("#{row}", "#{column}", 1, "#{length}");
+        JS
+      end
+
+      #
+      # Puts string at the coordinates specified.
+      #
+      # @param [String] str the string to set
+      # @param [Fixnum] row the x coordinate of the location on the screen.
+      # @param [Fixnum] column the y coordinate of the location on the screen.
+      #
+      def put_string(str, row, column)
+        move_to(row, column)
+        @browser.execute_script <<-JS
+          VIR3270.pasteByTyping("#{str}");
+        JS
+        quiet_period
+      end
+
+      #
+      # Moves string at the coordinates specified.
+      #
+      # @param [Fixnum] row the x coordinate of the location on the screen.
+      # @param [Fixnum] column the y coordinate of the location on the screen.
+      #
+      def move_to(row, column)
+        @browser.execute_script <<-JS
+          var row = parseInt("#{row}", 10);
+          var col = parseInt("#{column}", 10);
+
+          VIR3270.moveCursorToPos(VIR3270.posFromRowCol(row, col));
+        JS
+      end
+
+      #
+      # Sends keystrokes to the host, including function keys.
+      #
+      # @param [String] keys keystokes up to 255 in length
+      #
+      def send_keys(keys)
+        char_input_keys = ['ErEof','Reset']
+        if char_input_keys.include?(keys)
+          @browser.execute_script <<-JS
+            VIR3270.charInput("#{keys}");
+          JS
+        else
+          @browser.execute_script <<-JS
+            sendWithSpecialKey("#{keys}");
+          JS
+        end
+        quiet_period
+      end
+
+      #
+      # Wait for the string to appear at the specified location
+      #
+      # @param [String] str the string to wait for
+      # @param [Fixnum] row the x coordinate of location
+      # @param [Fixnum] column the y coordinate of location
+      #
+      def wait_for_string(str, row, column)
+        total_time = 0.0
+        sleep_time = 0.5
+        while get_string(row, column, str.length) != str do
+          sleep sleep_time
+          total_time = total_time + sleep_time
+          break if total_time >= @max_wait_time
+        end
+      end
+
+      #
+      # Waits for the host to not send data for a specified number of seconds
+      #
+      # @param [Fixnum] seconds the maximum number of seconds to wait
+      #
+      def wait_for_host(seconds)
+        milliseconds = seconds * 1000
+        sleep(WAIT_SLEEP_INTERVAL)
+        @browser.execute_script <<-JS
+          function virtelWaiting(){
+              if (VIR3270.waitlocked === false)
+                {return true;}
+              else
+                {return false;}
+          };
+
+          function waitOnVirtel(){
+            for (var count = 1; ; count++) {
+                if (setInterval(virtelWaiting(), 200))
+                    {
+                      return true;
+                    }
+                }
+            }
+          setTimeout(waitOnVirtel(), "#{milliseconds}");
+        JS
+      end
+
+      #
+      # Waits until the cursor is at the specified location.
+      #
+      # @param [Fixnum] row the x coordinate of the location
+      # @param [Fixnum] column the y coordinate of the location
+      #
+      def wait_until_cursor_at(row, column)
+        wait_until do
+          @browser.execute_script <<-JS
+            return (VIR3270.rowFromPos(VIR3270.cursorPosn) === parseInt("#{row}", 10)) && (VIR3270.colFromPos(VIR3270.cursorPosn) === parseInt("#{column}", 10))
+          JS
+        end
+      end
+
+      #
+      # Returns the text of the active screen
+      #
+      # @return [String]
+      #
+      def text
+        @browser.execute_script <<-JS
+          VIR3270.collectText(1,1,VIR3270.rows,VIR3270.cols)
+        JS
+      end
+
+      #
+      # Creates a method to take screenshot of the active screen.
+      #
+      # @param [String] filename the path and name of the screenshot file to be saved
+      #
+      def screenshot(filename)
+        File.delete(filename) if File.exists?(filename)
+
+        @browser.screenshot.save(filename)
+      end
+
+      def start_virtel_browser
+        begin
+          @browser = Watir::Browser.new :chrome
+          @browser.goto(@url)
+        rescue Exception => e
+          $stderr.puts e
+        end
+      end
+
+      private
+
+      def quiet_period
+        wait_for_host(max_wait_time)
+      end
+
+      def max_wait_time
+        @max_wait_time ||= 10
+      end
+    end
+  end
+end

data/lib/te3270/version.rb

@@ -1,4 +1,4 @@
 module TE3270
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end
 

data/spec/lib/te3270/accessors_spec.rb

@@ -14,34 +14,34 @@ describe TE3270::Accessors do
   let(:screen_object) { AccessorsTestScreen.new platform }
 
   before(:each) do
-    screen_object.stub(:platform).and_return platform
+    allow(screen_object).to receive(:platform).and_return platform
   end
 
   describe "text_field accessors" do
 
     it 'should generate a method to retrieve the value' do
-      screen_object.should respond_to :method_name
+      expect(screen_object).to respond_to(:method_name)
     end
 
     it 'should generate a method to set the value' do
-      screen_object.should respond_to :method_name=
+      expect(screen_object).to respond_to(:method_name=)
     end
 
     it 'should not generate a method to set the value if it is not editable' do
-      screen_object.should_not respond_to :read_only=
+      expect(screen_object).not_to respond_to(:read_only=)
     end
 
     it 'should default to being editable when it is not specified' do
-      screen_object.should respond_to :default_editable=
+      expect(screen_object).to respond_to :default_editable=
     end
 
     it 'should use the platform to get the text value' do
-      platform.should_receive(:get_string).with(1, 2, 10).and_return('abc')
-      screen_object.method_name.should == 'abc'
+      expect(platform).to receive(:get_string).with(1, 2, 10).and_return('abc')
+      expect(screen_object.method_name).to eql 'abc'
     end
 
     it 'should use the platform to set the text value' do
-      platform.should_receive(:put_string).with('abc', 1, 2)
+      expect(platform).to receive(:put_string).with('abc', 1, 2)
       screen_object.method_name = 'abc'
     end
 

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

@@ -1,162 +1,171 @@
-if Gem.win_platform?
+require 'spec_helper'
 
-  require 'spec_helper'
 
-  describe TE3270::Emulators::Extra do
+describe TE3270::Emulators::Extra do
 
-    let(:extra) { TE3270::Emulators::Extra.new }
-
-    before(:each) do
-      WIN32OLE.stub(:new).and_return extra_system
-      extra.instance_variable_set(:@session_file, 'the_file')
-      File.stub(:exists).and_return false
+  unless Gem.win_platform?
+    class WIN32OLE
     end
+  end
 
+  let(:extra) do
+    allow_any_instance_of(TE3270::Emulators::Extra).to receive(:require) unless Gem.win_platform?
+    TE3270::Emulators::Extra.new
+  end
 
-    describe "global behaviors" do
-      it 'should start a new terminal' do
-        WIN32OLE.should_receive(:new).and_return(extra_system)
-        extra.connect
-      end
+  before(:each) do
+    allow(WIN32OLE).to receive(:new).and_return extra_system
+    extra.instance_variable_set(:@session_file, 'the_file')
+    allow(File).to receive(:exists).and_return false
+  end
 
-      it 'should open a session' do
-        extra_sessions.should_receive(:Open).and_return(extra_session)
-        extra.connect
-      end
 
-      it 'should not display the splash screen if version is higher than 9' do
-        extra_system.should_receive(:Version).and_return("9.2")
-        extra_sessions.should_receive(:VisibleOnStartup=).with(true)
-        extra.connect
-      end
+  describe "global behaviors" do
+    it 'should start a new terminal' do
+      expect(WIN32OLE).to receive(:new).and_return(extra_system)
+      extra.connect
+    end
 
-      it 'should call a block allowing the session file to be set' do
-        extra_sessions.should_receive(:Open).with('blah.edp').and_return(extra_session)
-        extra.connect do |platform|
-          platform.session_file = 'blah.edp'
-        end
-      end
+    it 'should open a session' do
+      expect(extra_sessions).to receive(:Open).and_return(extra_session)
+      extra.connect
+    end
 
-      it 'should raise an error when the session file is not set' do
-        extra.instance_variable_set(:@session_file, nil)
-        expect { extra.connect }.to raise_error('The session file must be set in a block when calling connect with the Extra emulator.')
-      end
+    it 'should not display the splash screen if version is higher than 9' do
+      expect(extra_system).to receive(:Version).and_return("9.2")
+      expect(extra_sessions).to receive(:VisibleOnStartup=).with(true)
+      extra.connect
+    end
 
-      it 'should take the visible value from a block' do
-        extra_session.should_receive(:Visible=).with(false)
-        extra.connect do |platform|
-          platform.visible = false
-        end
+    it 'should call a block allowing the session file to be set' do
+      expect(extra_sessions).to receive(:Open).with('blah.edp').and_return(extra_session)
+      extra.connect do |platform|
+        platform.session_file = 'blah.edp'
       end
+    end
 
-      it 'should default to visible when not specified' do
-        extra_session.should_receive(:Visible=).with(true)
-        extra.connect
-      end
+    it 'should raise an error when the session file is not set' do
+      extra.instance_variable_set(:@session_file, nil)
+      expect { extra.connect }.to raise_error('The session file must be set in a block when calling connect with the Extra emulator.')
+    end
 
-      it 'should take the window state value from the block' do
-        extra_session.should_receive(:WindowState=).with(2)
-        extra.connect do |platform|
-          platform.window_state = :maximized
-        end
+    it 'should take the visible value from a block' do
+      expect(extra_session).to receive(:Visible=).with(false)
+      extra.connect do |platform|
+        platform.visible = false
       end
+    end
 
-      it 'should default to window state normal when not specified' do
-        extra_session.should_receive(:WindowState=).with(1)
-        extra.connect
-      end
+    it 'should default to visible when not specified' do
+      expect(extra_session).to receive(:Visible=).with(true)
+      extra.connect
+    end
 
-      it 'should default to being visible' do
-        extra_session.should_receive(:Visible=).with(true)
-        extra.connect
+    it 'should take the window state value from the block' do
+      expect(extra_session).to receive(:WindowState=).with(2)
+      extra.connect do |platform|
+        platform.window_state = :maximized
       end
+    end
 
-      it 'should get the screen for the active session' do
-        extra_session.should_receive(:Screen).and_return(extra_screen)
-        extra.connect
-      end
+    it 'should default to window state normal when not specified' do
+      expect(extra_session).to receive(:WindowState=).with(1)
+      extra.connect
+    end
 
-      it 'should get the area from the screen' do
-        extra_screen.should_receive(:SelectAll).and_return(extra_area)
-        extra.connect
-      end
+    it 'should default to being visible' do
+      expect(extra_session).to receive(:Visible=).with(true)
+      extra.connect
+    end
 
-      it 'should disconnect from a session' do
-        extra_session.should_receive(:Close)
-        extra.connect
-        extra.disconnect
-      end
+    it 'should get the screen for the active session' do
+      expect(extra_session).to receive(:Screen).and_return(extra_screen)
+      extra.connect
     end
 
-    describe "interacting with text fields" do
-      it 'should get the value from the screen' do
-        extra_screen.should_receive(:GetString).with(1, 2, 10).and_return('blah')
-        extra.connect
-        extra.get_string(1, 2, 10).should == 'blah'
-      end
+    it 'should get the area from the screen' do
+      expect(extra_screen).to receive(:SelectAll).and_return(extra_area)
+      extra.connect
+    end
 
-      it 'should put the value on the screen' do
-        wait_collection = double('wait')
-        extra_screen.should_receive(:PutString).with('blah', 1, 2)
-        extra_screen.should_receive(:WaitHostQuiet).and_return(wait_collection)
-        wait_collection.should_receive(:Wait).with(1000)
-        extra.connect
-        extra.put_string('blah', 1, 2)
-      end
+    it 'should disconnect from a session' do
+      expect(extra_session).to receive(:Close)
+      extra.connect
+      extra.disconnect
     end
+  end
 
-    describe "interacting with the screen" do
-      it 'should know how to send function keys' do
-        wait_collection = double('wait')
-        extra_screen.should_receive(:SendKeys).with('<Clear>')
-        extra_screen.should_receive(:WaitHostQuiet).and_return(wait_collection)
-        wait_collection.should_receive(:Wait).with(1000)
-        extra.connect
-        extra.send_keys(TE3270.Clear)
-      end
+  describe "interacting with text fields" do
+    it 'should get the value from the screen' do
+      expect(extra_screen).to receive(:GetString).with(1, 2, 10).and_return('blah')
+      extra.connect
+      expect(extra.get_string(1, 2, 10)).to eql 'blah'
+    end
 
-      it 'should wait for a string to appear' do
-        wait_col = double('wait')
-        extra_screen.should_receive(:WaitForString).with('The String', 3, 10).and_return(wait_col)
-        extra_system.should_receive(:TimeoutValue).and_return(30000)
-        wait_col.should_receive(:Wait).with(30000)
-        extra.connect
-        extra.wait_for_string('The String', 3, 10)
-      end
+    it 'should put the value on the screen' do
+      wait_collection = double('wait')
+      expect(extra_screen).to receive(:PutString).with('blah', 1, 2)
+      expect(extra_screen).to receive(:WaitHostQuiet).and_return(wait_collection)
+      expect(wait_collection).to receive(:Wait).with(1000)
+      extra.connect
+      extra.put_string('blah', 1, 2)
+    end
+  end
 
-      it 'should wait for the host to be quiet' do
-        wait_col = double('wait')
-        extra_screen.should_receive(:WaitHostQuiet).and_return(wait_col)
-        wait_col.should_receive(:Wait).with(4000)
-        extra.connect
-        extra.wait_for_host(4)
-      end
+  describe "interacting with the screen" do
+    it 'should know how to send function keys' do
+      wait_collection = double('wait')
+      expect(extra_screen).to receive(:SendKeys).with('<Clear>')
+      expect(extra_screen).to receive(:WaitHostQuiet).and_return(wait_collection)
+      expect(wait_collection).to receive(:Wait).with(1000)
+      extra.connect
+      extra.send_keys(TE3270.Clear)
+    end
 
-      it 'should wait until the cursor is at a position' do
-        wait_col = double('wait')
-        extra_screen.should_receive(:WaitForCursor).with(5, 8).and_return(wait_col)
-        extra_system.should_receive(:TimeoutValue).and_return(30000)
-        wait_col.should_receive(:Wait).with(30000)
-        extra.connect
-        extra.wait_until_cursor_at(5, 8)
-      end
+    it 'should wait for a string to appear' do
+      wait_col = double('wait')
+      expect(extra_screen).to receive(:WaitForString).with('The String', 3, 10).and_return(wait_col)
+      expect(extra_system).to receive(:TimeoutValue).and_return(30000)
+      expect(wait_col).to receive(:Wait).with(30000)
+      extra.connect
+      extra.wait_for_string('The String', 3, 10)
+    end
+
+    it 'should wait for the host to be quiet' do
+      wait_col = double('wait')
+      expect(extra_screen).to receive(:WaitHostQuiet).and_return(wait_col)
+      expect(wait_col).to receive(:Wait).with(4000)
+      extra.connect
+      extra.wait_for_host(4)
+    end
+
+    it 'should wait until the cursor is at a position' do
+      wait_col = double('wait')
+      expect(extra_screen).to receive(:WaitForCursor).with(5, 8).and_return(wait_col)
+      expect(extra_system).to receive(:TimeoutValue).and_return(30000)
+      expect(wait_col).to receive(:Wait).with(30000)
+      extra.connect
+      extra.wait_until_cursor_at(5, 8)
+    end
+
+    if Gem.win_platform?
 
       it 'should take screenshots' do
         take = double('Take')
-        extra_session.should_receive(:WindowHandle).and_return(123)
-        Win32::Screenshot::Take.should_receive(:of).with(:window, hwnd: 123).and_return(take)
-        take.should_receive(:write).with('image.png')
+        expect(extra_session).to receive(:WindowHandle).and_return(123)
+        expect(Win32::Screenshot::Take).to receive(:of).with(:window, hwnd: 123).and_return(take)
+        expect(take).to receive(:write).with('image.png')
         extra.connect
         extra.screenshot('image.png')
       end
 
       it 'should make the window visible before taking a screenshot' do
         take = double('Take')
-        extra_session.should_receive(:WindowHandle).and_return(123)
-        Win32::Screenshot::Take.should_receive(:of).with(:window, hwnd: 123).and_return(take)
-        take.should_receive(:write).with('image.png')
-        extra_session.should_receive(:Visible=).once.with(true)
-        extra_session.should_receive(:Visible=).twice.with(false)
+        expect(extra_session).to receive(:WindowHandle).and_return(123)
+        expect(Win32::Screenshot::Take).to receive(:of).with(:window, hwnd: 123).and_return(take)
+        expect(take).to receive(:write).with('image.png')
+        expect(extra_session).to receive(:Visible=).once.with(true)
+        expect(extra_session).to receive(:Visible=).twice.with(false)
         extra.connect do |emulator|
           emulator.visible = false
         end
@@ -164,23 +173,24 @@ if Gem.win_platform?
       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')
-        extra_session.should_receive(:WindowHandle).and_return(123)
-        Win32::Screenshot::Take.should_receive(:of).with(:window, hwnd: 123).and_return(take)
-        take.should_receive(:write).with('image.png')
+        expect(extra_session).to receive(:WindowHandle).and_return(123)
+        expect(Win32::Screenshot::Take).to receive(:of).with(:window, hwnd: 123).and_return(take)
+        expect(take).to receive(:write).with('image.png')
         extra.connect
         extra.screenshot('image.png')
       end
+    end
 
-      it "should get the screen text" do
-        extra_area.should_receive(:Value).and_return('blah')
-        extra.connect
-        extra.text.should == 'blah'
-      end
-
+    it "should get the screen text" do
+      expect(extra_area).to receive(:Value).and_return('blah')
+      extra.connect
+      expect(extra.text).to eql 'blah'
     end
-  end
 
+  end
 end
+
+