rmodbus-ccutrer 2.0.0

data/spec/rtu_via_tcp_server_spec.rb

@@ -0,0 +1,89 @@
+# -*- coding: ascii
+require "rmodbus"
+
+describe ModBus::RTUViaTCPServer do
+  before :all do
+    @port = 8502
+    begin
+      @server = ModBus::RTUViaTCPServer.new(@port)
+      @server_slave = @server.with_slave(1)
+      @server_slave.coils = [1,0,1,1]
+      @server_slave.discrete_inputs = [1,1,0,0]
+      @server_slave.holding_registers = [1,2,3,4]
+      @server_slave.input_registers = [1,2,3,4]
+      @server.promiscuous = true
+      @server.start
+    rescue Errno::EADDRINUSE
+      @port += 1
+      retry
+    end
+    @cl = ModBus::RTUClient.new('127.0.0.1', @port)
+    @cl.read_retries = 1
+    @slave = @cl.with_slave(1)
+    # pretend this is a serialport and we're just someone else on the same bus
+    @io = @cl.instance_variable_get(:@io)
+  end
+
+  before do
+    @server.debug = false
+  end
+
+  it "should have options :host" do
+    host = '192.168.0.1'
+    srv = ModBus::RTUViaTCPServer.new(1010, :host => '192.168.0.1')
+    srv.host.should eql(host)
+  end
+
+  it "should have options :max_connection" do
+    max_conn = 5
+    srv = ModBus::RTUViaTCPServer.new(1010, :max_connection => 5)
+    srv.maxConnections.should eql(max_conn)
+  end
+
+  it "should properly ignore responses from other slaves" do
+    request = "\x10\x03\x0\x1\x0\x1\xd6\x8b"
+    response = "\x10\x83\x1\xd0\xf5"
+    @server.debug = true
+    @server.should receive(:log).ordered.with("Server RX (8 bytes): [10][03][00][01][00][01][d6][8b]")
+    @server.should receive(:log).ordered.with("Server RX function 3 to 16: {:quant=>1, :addr=>1}")
+    @server.should receive(:log).ordered.with("Server RX (5 bytes): [10][83][01][d0][f5]")
+    @server.should receive(:log).ordered.with("Server RX response 3 from 16: {:err=>1}")
+    @server.should receive(:log).ordered.with("Server RX (8 bytes): [01][01][00][00][00][01][fd][ca]")
+    @server.should receive(:log).ordered.with("Server RX function 1 to 1: {:quant=>1, :addr=>0}")
+    @server.should receive(:log).ordered.with("Server TX (6 bytes): [01][01][01][01][90][48]")
+    @io.write(request)
+    @io.write(response)
+    # just to prove the server can still handle subsequent requests
+    @slave.read_coils(0, 1).should == [1]
+  end
+
+  it "should properly ignore functions from other slaves that it doesn't understand" do
+    request = "\x10\x41\x0\x1\x0\x1\x0\x5\x0\x1\xb1\x00"
+    response = "\x10\xc1\x1\xe0\x55"
+    @io.write(request)
+    @io.write(response)
+    # just to prove the server can still handle subsequent requests
+    @slave.read_coils(0, 1).should == [1]
+  end
+
+  it "should properly ignore utter garbage on the line from starting up halfway through a conversation" do
+    response = "garbage" * 50 + "\x1\x55\xe0"
+    @io.write(response)
+    # just to prove the server can still handle subsequent requests
+    @slave.read_coils(0, 1).should == [1]
+  end
+
+  it "should send exception if request is malformed" do
+    lambda { @slave.query("\x01\x01") }.should raise_exception(
+                                                   ModBus::Errors::ModBusTimeout)
+  end
+
+  after :all do
+    @cl.close unless @cl.closed?
+    @server.stop unless @server.stopped?
+    while GServer.in_service?(@port)
+      sleep(0.01)
+    end
+    @server.stop
+  end
+end

data/spec/slave_spec.rb

@@ -0,0 +1,55 @@
+# -*- coding: ascii
+require 'rmodbus'
+
+describe ModBus::Client::Slave do
+  before do
+    @slave = ModBus::Client.new.with_slave(1)
+
+    @slave.stub(:query).and_return('')
+  end
+
+  it "should support function 'read coils'" do
+    @slave.should_receive(:query).with("\x1\x0\x13\x0\x13").and_return("\xcd\x6b\x5")    
+    @slave.read_coils(0x13,0x13).should == [1,0,1,1, 0,0,1,1, 1,1,0,1, 0,1,1,0,  1,0,1]
+  end
+
+  it "should support function 'read discrete inputs'" do
+    @slave.should_receive(:query).with("\x2\x0\xc4\x0\x16").and_return("\xac\xdb\x35")    
+    @slave.read_discrete_inputs(0xc4,0x16).should == [0,0,1,1, 0,1,0,1, 1,1,0,1, 1,0,1,1, 1,0,1,0, 1,1]
+  end
+
+  it "should support function 'read holding registers'" do
+    @slave.should_receive(:query).with("\x3\x0\x6b\x0\x3").and_return("\x2\x2b\x0\x0\x0\x64")    
+    @slave.read_holding_registers(0x6b,0x3).should == [0x022b, 0x0000, 0x0064]
+  end
+
+  it "should support function 'read input registers'" do
+    @slave.should_receive(:query).with("\x4\x0\x8\x0\x1").and_return("\x0\xa")    
+    @slave.read_input_registers(0x8,0x1).should == [0x000a]
+  end
+
+  it "should support function 'write single coil'" do
+    @slave.should_receive(:query).with("\x5\x0\xac\xff\x0").and_return("\xac\xff\x00")    
+    @slave.write_single_coil(0xac,0x1).should == @slave
+  end
+
+  it "should support function 'write single register'" do
+    @slave.should_receive(:query).with("\x6\x0\x1\x0\x3").and_return("\x1\x0\x3")    
+    @slave.write_single_register(0x1,0x3).should == @slave
+  end
+
+  it "should support function 'write multiple coils'" do
+    @slave.should_receive(:query).with("\xf\x0\x13\x0\xa\x2\xcd\x1").and_return("\x13\x0\xa")    
+    @slave.write_multiple_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]).should == @slave
+  end
+
+  it "should support function 'write multiple registers'" do
+    @slave.should_receive(:query).with("\x10\x0\x1\x0\x3\x6\x0\xa\x1\x2\xf\xf").and_return("\x1\x0\x3")    
+    @slave.write_multiple_registers(0x1,[0x000a,0x0102, 0xf0f]).should == @slave
+  end
+
+  it "should support function 'mask write register'" do
+    @slave.should_receive(:query).with("\x16\x0\x4\x0\xf2\x0\2").and_return("\x4\x0\xf2\x0\x2")
+    @slave.mask_write_register(0x4, 0xf2, 0x2).should == @slave
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,54 @@
+# -*- coding: ascii
+require "rmodbus"
+
+class RaiseResponseMismatch
+  def initialize(message, request, response)
+    @expected_message, @expected_request, @expected_response = message, request, response
+  end
+
+  def matches?(given_block)
+    begin
+      given_block.call
+    rescue ModBus::Errors::ResponseMismatch => e
+      @actual_message = e.message
+      @actual_request = e.request
+      @actual_response = e.response
+
+      @with_expected_message = verify_message
+      @with_expected_request = @expected_request == @actual_request
+      @with_expected_response = @expected_response == @actual_response
+    end
+    @with_expected_message & @with_expected_request & @with_expected_response
+  end
+
+  def failure_message
+    unless @with_expected_message
+      return "Expected message '#{@expected_message}', got '#{@actual_message}'"
+    end
+
+    unless @with_expected_request
+      return "Expected request #{logging_bytes @expected_request}, got #{logging_bytes @actual_request}"
+    end
+
+    unless @with_expected_response
+      return "Expected response #{logging_bytes @expected_response}, got #{logging_bytes @actual_response}"
+    end
+  end
+
+  def verify_message
+    case  @expected_message
+      when nil
+        true
+      when Regexp
+         @expected_message =~ @actual_message
+      else
+         @expected_message == @actual_message
+    end
+  end
+end
+
+module RaiseResponseMatcher
+  def raise_response_mismatch(message, request, response)
+    RaiseResponseMismatch.new(message, request, response)
+  end
+end

data/spec/tcp_client_spec.rb

@@ -0,0 +1,88 @@
+# -*- coding: ascii
+require 'rmodbus'
+
+describe ModBus::TCPClient do
+  describe "method 'query'" do    
+    before(:each) do
+      @uid = 1
+      @sock = double('Socket')
+      @adu = "\000\001\000\000\000\001\001"
+  
+      Socket.should_receive(:tcp).with('127.0.0.1', 1502, nil, nil, hash_including(:connect_timeout)).and_return(@sock)
+      @sock.stub(:read).with(0).and_return('')
+      @cl = ModBus::TCPClient.new('127.0.0.1', 1502)
+      @slave = @cl.with_slave(@uid)
+    end
+    
+    it 'should send valid MBAP Header' do
+      @adu[0,2] = @slave.transaction.next.to_word
+      @sock.should_receive(:write).with(@adu)
+      @sock.should_receive(:read).with(7).and_return(@adu)
+      @slave.query('').should == nil
+    end
+    
+    it 'should not throw exception and white next packet if get other transaction' do
+      @adu[0,2] = @slave.transaction.next.to_word
+      @sock.should_receive(:write).with(@adu)
+      @sock.should_receive(:read).with(7).and_return("\000\002\000\000\000\001" + @uid.chr)
+      @sock.should_receive(:read).with(7).and_return("\000\001\000\000\000\001" + @uid.chr)
+
+      expect{ @slave.query('') }.to_not raise_error
+    end
+    
+    it 'should throw timeout exception if do not get own transaction' do
+      @slave.read_retries = 2
+      @adu[0,2] = @slave.transaction.next.to_word
+      @sock.should_receive(:write).at_least(1).times.with(/\.*/)
+      @sock.should_receive(:read).at_least(1).times.with(7).and_return("\000\x3\000\000\000\001" + @uid.chr)
+
+      expect{ @slave.query('') }.to raise_error(ModBus::Errors::ModBusTimeout, "Timed out during read attempt")
+    end
+
+    
+    it 'should return only data from PDU' do
+      request = "\x3\x0\x6b\x0\x3"
+      response = "\x3\x6\x2\x2b\x0\x0\x0\x64"
+      @adu = @slave.transaction.next.to_word + "\x0\x0\x0\x9" + @uid.chr + request
+      @sock.should_receive(:write).with(@adu[0,4] + "\0\6" + @uid.chr + request)
+      @sock.should_receive(:read).with(7).and_return(@adu[0,7])
+      @sock.should_receive(:read).with(8).and_return(response)
+  
+      @slave.query(request).should == response[2..-1]
+    end
+    
+    it 'should sugar connect method' do
+        ipaddr, port = '127.0.0.1', 502
+        Socket.should_receive(:tcp).with(ipaddr, port, nil, nil, hash_including(:connect_timeout)).and_return(@sock)
+        @sock.should_receive(:closed?).and_return(false)
+        @sock.should_receive(:close)
+        ModBus::TCPClient.connect(ipaddr, port) do |cl|
+          cl.ipaddr.should == ipaddr
+          cl.port.should == port
+        end
+      end
+    
+    it 'should have closed? method' do
+      @sock.should_receive(:closed?).and_return(false)
+      @cl.closed?.should == false
+  
+      @sock.should_receive(:closed?).and_return(false)
+      @sock.should_receive(:close)
+  
+      @cl.close
+  
+      @sock.should_receive(:closed?).and_return(true)
+      @cl.closed?.should == true
+    end 
+    
+    it 'should give slave object in block' do
+      @cl.with_slave(1) do |slave|
+        slave.uid = 1
+      end
+    end
+  end  
+  
+  it "should tune connection timeout" do
+    lambda { ModBus::TCPClient.new('81.123.231.11', 1999, :connect_timeout => 0.001) }.should raise_error(ModBus::Errors::ModBusTimeout)
+  end
+end

data/spec/tcp_server_spec.rb

@@ -0,0 +1,158 @@
+# -*- coding: ascii
+require "rmodbus"
+
+describe ModBus::TCPServer do
+  before :all do
+    unit_ids = (1..247).to_a.shuffle
+    valid_unit_id = unit_ids.first
+    @invalid_unit_id = unit_ids.last
+    @port = 8502
+    begin
+      @server = ModBus::TCPServer.new(@port)
+      @server_slave = @server.with_slave(valid_unit_id)
+      @server_slave.coils = [1,0,1,1]
+      @server_slave.discrete_inputs = [1,1,0,0]
+      @server_slave.holding_registers = [1,2,3,4]
+      @server_slave.input_registers = [1,2,3,4]
+      @server.start
+    rescue Errno::EADDRINUSE
+      @port += 1
+      retry
+    end
+    @cl = ModBus::TCPClient.new('127.0.0.1', @port)
+    @cl.read_retries = 1
+    @slave = @cl.with_slave(valid_unit_id)
+  end
+
+  it "should succeed if UID is broadcast" do
+    @cl.with_slave(0).write_coil(1,1)
+    # have to wait for the server to process it
+    sleep 1
+    @server_slave.coils[1].should == 1
+  end
+
+  it "should fail if UID is mismatched" do
+    lambda { @cl.with_slave(@invalid_unit_id).read_coils(1,3) }.should raise_exception(
+      ModBus::Errors::ModBusTimeout
+    )
+  end
+
+  it "should send exception if function not supported" do
+    lambda { @slave.query('0x43') }.should raise_exception(
+      ModBus::Errors::IllegalFunction,
+      "The function code received in the query is not an allowable action for the server"
+    )
+  end
+
+  it "should send exception if quanity of registers are more than 0x7d" do
+    lambda { @slave.read_holding_registers(0, 0x7e) }.should raise_exception(
+      ModBus::Errors::IllegalDataValue,
+      "A value contained in the query data field is not an allowable value for server"
+    )
+  end
+
+  it "shouldn't send exception if quanity of coils are more than 0x7d0" do
+    lambda { @slave.read_coils(0, 0x7d1) }.should raise_exception(
+      ModBus::Errors::IllegalDataValue,
+      "A value contained in the query data field is not an allowable value for server"
+    )
+  end
+
+  it "should send exception if addr not valid" do
+    lambda { @slave.read_coils(2, 8) }.should raise_exception(
+      ModBus::Errors::IllegalDataAddress,
+      "The data address received in the query is not an allowable address for the server"
+    )
+  end
+
+  it "should send exception if function not supported" do
+    lambda { @slave.query('0x43') }.should raise_exception(
+                                               ModBus::Errors::IllegalFunction,
+                                               "The function code received in the query is not an allowable action for the server"
+                                           )
+  end
+
+  it "should calc a many requests" do
+    @slave.read_coils(1,2)
+    @slave.write_multiple_registers(0,[9,9,9,])
+    @slave.read_holding_registers(0,3).should == [9,9,9]
+  end
+
+  it "should supported function 'read coils'" do
+    @slave.read_coils(0,3).should == @server_slave.coils[0,3]
+  end
+
+  it "should supported function 'read coils' with more than 125 in one request" do
+    @server_slave.coils = Array.new( 1900, 1 )
+    @slave.read_coils(0,1900).should == @server_slave.coils[0,1900]
+  end
+
+  it "should supported function 'read discrete inputs'" do
+    @slave.read_discrete_inputs(1,3).should == @server_slave.discrete_inputs[1,3]
+  end
+
+  it "should supported function 'read holding registers'" do
+    @slave.read_holding_registers(0,3).should == @server_slave.holding_registers[0,3]
+  end
+
+  it "should supported function 'read input registers'" do
+    @slave.read_input_registers(2,2).should == @server_slave.input_registers[2,2]
+  end
+
+  it "should supported function 'write single coil'" do
+    @server_slave.coils[3] = 0
+    @slave.write_single_coil(3,1)
+    @server_slave.coils[3].should == 1
+  end
+
+  it "should supported function 'write single register'" do
+    @server_slave.holding_registers[3] = 25
+    @slave.write_single_register(3,35)
+    @server_slave.holding_registers[3].should == 35
+  end
+
+  it "should supported function 'write multiple coils'" do
+    @server_slave.coils = [1,1,1,0, 0,0,0,0, 0,0,0,0, 0,1,1,1]
+    @slave.write_multiple_coils(3, [1, 0,1,0,1, 0,1,0,1])
+    @server_slave.coils.should == [1,1,1,1, 0,1,0,1, 0,1,0,1, 0,1,1,1]
+  end
+
+  it "should supported function 'write multiple registers'" do
+    @server_slave.holding_registers = [1,2,3,4,5,6,7,8,9]
+    @slave.write_multiple_registers(3,[1,2,3,4,5])
+    @server_slave.holding_registers.should == [1,2,3,1,2,3,4,5,9]
+  end
+
+  it "should support function 'mask_write_register'" do
+    @server_slave.holding_registers = [0x12]
+    @slave.mask_write_register(0, 0xf2, 0x25)
+    @server_slave.holding_registers.should == [0x17]
+  end
+
+  it "should support function 'read_write_multiple_registers'" do
+    @server_slave.holding_registers = [1,2,3,4,5,6,7,8,9]
+    @slave.read_write_multiple_registers(0, 5, 4, [3,2,1]).should == [1,2,3,4,3]
+    @server_slave.holding_registers.should == [1,2,3,4,3,2,1,8,9]
+  end
+
+  it "should have options :host" do
+    host = '192.168.0.1'
+    srv = ModBus::TCPServer.new(1010, :host => '192.168.0.1')
+    srv.host.should eql(host)
+  end
+
+  it "should have options :max_connection" do
+    max_conn = 5
+    srv = ModBus::TCPServer.new(1010, :max_connection => 5)
+    srv.maxConnections.should eql(max_conn)
+  end
+
+  after :all do
+    @cl.close unless @cl.closed?
+    @server.stop unless @server.stopped?
+    while GServer.in_service?(@port)
+      sleep(0.01)
+    end
+    @server.stop
+  end
+end