rmodbus 1.3.2 → 2.1.2

data/spec/proxy_spec.rb

@@ -1,74 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe Array do
-  before do
-    @slave = double('ModBus Slave')
-    @coil_proxy = ModBus::ReadWriteProxy.new(@slave, :coil)
-    @discrete_input_proxy = ModBus::ReadOnlyProxy.new(@slave, :discrete_input)
-    @holding_register_proxy = ModBus::ReadWriteProxy.new(@slave, :holding_register)
-    @input_register_proxy = ModBus::ReadOnlyProxy.new(@slave, :input_register)
-  end
-
-  # Handle all of the coil methods
-  it "should call read_coil" do
-    @slave.should_receive(:read_coil).with(0, 1)
-    @coil_proxy[0]
-  end
-  it "should call read_coils" do
-    @slave.should_receive(:read_coils).with(0, 2)
-    @coil_proxy[0..1]
-  end
-  it "should call write_coil" do
-    @slave.should_receive(:write_coil).with(0, 1)
-    @coil_proxy[0] = 1
-  end
-  it "should call write_coils" do
-    @slave.should_receive(:write_coils).with(0, [0, 0])
-    @coil_proxy[0..1] = [0, 0]
-  end
-
-
-  # Discrete input tests
-  it "should call read_discrete_input" do
-    @slave.should_receive(:read_discrete_input).with(0, 1)
-    @discrete_input_proxy[0]
-  end
-
-  it "should call read_discrete_inputs" do
-    @slave.should_receive(:read_discrete_inputs).with(0, 2)
-    @discrete_input_proxy[0..1]
-  end
-
-
-  # Holding Register Tess
-  it "should call read_holding_register" do
-    @slave.should_receive(:read_holding_register).with(0, 1)
-    @holding_register_proxy[0]
-  end
-  it "should call read_holding_registers" do
-    @slave.should_receive(:read_holding_registers).with(0, 2)
-    @holding_register_proxy[0..1]
-  end
-  it "should call write_holding_register" do
-    @slave.should_receive(:write_holding_register).with(0, 1)
-    @holding_register_proxy[0] = 1
-  end
-  it "should call write_holding_registers" do
-    @slave.should_receive(:write_holding_registers).with(0, [0, 0])
-    @holding_register_proxy[0..1] = [0, 0]
-  end
-
-
-  # Input Register Tests
-  it "should call read_discrete_input" do
-    @slave.should_receive(:read_input_register).with(0, 1)
-    @input_register_proxy[0]
-  end
-
-  it "should call read_discrete_inputs" do
-    @slave.should_receive(:read_input_registers).with(0, 2)
-    @input_register_proxy[0..1]
-  end
-end
-

data/spec/read_rtu_response_spec.rb

@@ -1,92 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-#Use public wrap method
-class ModBus::Client
-  include ModBus::RTU
-  def test_read_method(msg)
-    io = TestIO.new(msg)
-    read_rtu_response(io)
-  end
-
-end
-
-class TestIO
-  def initialize(msg)
-    @msg = msg
-  end
-
-  def read(num)
-    result = @msg[0,num]
-    @msg = @msg[num..-1]
-    result
-  end
-end
-
-describe "#read_rtu_response" do
-  before do
-    @cl_mb = ModBus::Client.new   
-  end
-
-  it "should read response for 'read coils'" do
-    resp = make_resp("\x1\x3\xcd\x6b\x05")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'read discrete inputs'" do
-    resp = make_resp("\x2\x3\xac\xdb\x35")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'read holding registers'" do
-    resp = make_resp("\x3\x6\x2\x2b\x0\x0\x0\x64")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'read input registers'" do
-    resp = make_resp("\x4\x2\x0\xa")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'write single coil'" do
-    resp = make_resp("\x5\x0\xac\xff\x0")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'write single register'" do
-    resp = make_resp("\x6\x0\x1\x0\x3")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'write multiple coils'" do
-    resp = make_resp("\xf\x0\x13\x0\xa")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response for 'write multiple registers'" do
-    resp = make_resp("\x10\x0\x1\x0\x2")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read response 'mask write register'" do
-    resp = make_resp("\x16\x0\x4\x0\xf2\x0\x25")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should read exception codes" do
-    resp = make_resp("\x84\x3")
-    @cl_mb.test_read_method(resp).should == resp 
-  end
-
-  it "should raise exception if function is illegal" do
-    resp =  make_resp("\x1f\x0\x1\x0\x2")
-    lambda{ @cl_mb.test_read_method(resp)}.should raise_error {
-      ModBus::Errors::IllegalFunction
-    }
-  end
-
-  def make_resp(msg)
-    "\x1" + msg + "\x2\x2" # slave + msg + mock_crc
-  end
-end
-

data/spec/response_mismach_spec.rb

@@ -1,163 +0,0 @@
-# -*- coding: ascii
-require "spec_helper"
-
-describe "response mismach" do
-  include RaiseResponseMatcher
-  before(:each) do
-    @slave = ModBus::Slave.new(1, nil)
-    @slave.raise_exception_on_mismatch = true
-  end
-
-  it "should raise error if function code is mismatch" do
-    request = "\x1\x0\x13\x0\x12"
-    response = "\x2\x3\xcd\xb6\x5"
-    mock_query!(request, response)
-
-    lambda{ @slave.read_coils(0x13,0x12) }.should raise_response_mismatch(
-      "Function code is mismatch (expected 1, got 2)",
-      request, response)
-  end
-
-  describe "read coils" do
-    it "should raise error if count of byte is mismatch" do
-      request = "\x1\x0\x13\x0\x12"
-      response = "\x1\x2\xcd\xb6"
-      mock_query!(request, response)
-
-      lambda{ @slave.read_coils(0x13,0x12) }.should raise_response_mismatch(
-        "Byte count is mismatch (expected 3, got 2 bytes)",
-        request, response)
-    end
-  end
-
-  describe "read discrete inputs" do
-    it "should raise error if count of byte is mismatch" do
-      request = "\x2\x0\x13\x0\x12"
-      response = "\x2\x2\xcd\xb6"
-      mock_query!(request, response)
-
-      lambda{ @slave.read_discrete_inputs(0x13,0x12) }.should raise_response_mismatch(
-        "Byte count is mismatch (expected 3, got 2 bytes)",
-        request, response)
-    end
-  end
-
-  describe "read holding registesrs" do
-    it "should raise error if count of registers is mismatch" do
-      request = "\x3\x0\x8\x0\x1"
-      response = "\x3\x4\x0\xa\x0\xb"
-      mock_query!(request, response)
-
-      lambda{ @slave.read_holding_registers(0x8,0x1) }.should raise_response_mismatch(
-        "Register count is mismatch (expected 1, got 2 regs)",
-        request, response)
-    end
-  end
-
-  describe "read input registesrs" do
-    it "should raise error if count of registers is mismatch" do
-      request = "\x4\x0\x8\x0\x2"
-      response = "\x4\x2\xa\x0"
-      mock_query!(request, response)
-
-      lambda{ @slave.read_input_registers(0x8,0x2) }.should raise_response_mismatch(
-        "Register count is mismatch (expected 2, got 1 regs)",
-        request, response)
-    end
-  end
-
-  describe "write single coil" do
-    it "should raise error if address of coil is mismatch" do
-      request = "\x5\x0\x8\xff\x0"
-      response = "\x5\x0\x9\xff\x0"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_coil(8,true) }.should raise_response_mismatch(
-        "Address is mismatch (expected 8, got 9)",
-        request, response)
-    end
-
-    it "should raise error if value of coil is mismatch" do
-      request = "\x5\x0\x8\xff\x0"
-      response = "\x5\x0\x8\x0\x0"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_coil(8,true) }.should raise_response_mismatch(
-        "Value is mismatch (expected 0xff00, got 0x0)",
-        request, response)
-    end
-  end
-
-  describe "write single register" do
-    it "should raise error if address of register is mismatch" do
-      request = "\x6\x0\x8\xa\xb"
-      response = "\x6\x0\x9\xa\xb"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_single_register(8,0x0a0b) }.should raise_response_mismatch(
-        "Address is mismatch (expected 8, got 9)",
-        request, response)
-    end
-
-    it "should raise error if value of register is mismatch" do
-      request = "\x6\x0\x8\xa\xb"
-      response = "\x6\x0\x8\x9\xb"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_single_register(8,0x0a0b) }.should raise_response_mismatch(
-        "Value is mismatch (expected 0xa0b, got 0x90b)",
-        request, response)
-    end
-  end
-
-  describe "write multiple coils" do
-    it "should raise error if address of first coil is mismatch" do
-      request = "\xf\x0\x13\x0\xa\2\xcd\x01"
-      response = "\xf\x0\x14\x0\xa"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]) }.should raise_response_mismatch(
-        "Address is mismatch (expected 19, got 20)",
-        request, response)
-   end
-
-   it "should raise error if quantity of coils is mismatch" do
-      request = "\xf\x0\x13\x0\xa\2\xcd\x01"
-      response = "\xf\x0\x13\x0\x9"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_coils(0x13,[1,0,1,1, 0,0,1,1, 1,0]) }.should raise_response_mismatch(
-        "Quantity is mismatch (expected 10, got 9)",
-        request, response)
-    end
-  end
-
-  describe "write multiple registers" do
-    it "should raise error if address of first register is mismatch" do
-      request = "\x10\x0\x1\x0\x2\x4\x0\xa\x1\x2"
-      response = "\x10\x0\x2\x0\x2"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_holding_registers(0x1,[0xa,0x102]) }.should raise_response_mismatch(
-        "Address is mismatch (expected 1, got 2)",
-        request, response)
-   end
-
-   it "should raise error if quantity of registers is mismatch" do
-      request = "\x10\x0\x1\x0\x2\x4\x0\xa\x1\x2"
-      response = "\x10\x0\x2\x0\x1"
-      mock_query!(request, response)
-
-      lambda{ @slave.write_holding_registers(0x1,[0xa,0x102]) }.should raise_response_mismatch(
-        "Quantity is mismatch (expected 2, got 1)",
-        request, response)
-    end
-  end
-
-
-  private
-  def mock_query!(request, response)
-    @slave.should_receive(:send_pdu).with(request)
-    @slave.should_receive(:read_pdu).and_return(response)
-  end
-end

data/spec/rtu_client_spec.rb

@@ -1,86 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::RTUClient do
-  before do 
-    @sp = double('Serial port')
-
-    SerialPort.should_receive(:new).with("/dev/port1", 9600, 8, 1, 0).and_return(@sp)    
-    SerialPort.stub(:public_method_defined?).with(:flush_input).and_return(true)
-
-    @sp.stub(:read_timeout=)
-    @sp.stub(:class).and_return(SerialPort)
-    @sp.should_receive(:flow_control=).with(SerialPort::NONE)
-    @sp.stub(:flush_input)
-
-    @cl = ModBus::RTUClient.new("/dev/port1", 9600, :data_bits => 8, :stop_bits => 1, :parity => SerialPort::NONE)
-    @slave = @cl.with_slave(1)
-    @slave.read_retries = 1
-  end
-
-  it "should ignore frame with other UID" do
-    request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
-    @sp.should_receive(:write).with("\1#{request}\xA6\x31")
-    @sp.should_receive(:read).with(2).and_return("\x2\x10")
-    @sp.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
-    lambda {@slave.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
-  end
-
-  it "should ignored frame with incorrect CRC" do
-    request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
-    @sp.should_receive(:write).with("\1#{request}\xA6\x31")
-    @sp.should_receive(:read).with(2).and_return("\x2\x10")
-    @sp.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
-    lambda {@slave.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
-  end
-  
-  it "should return value of registers"do
-    request = stab_valid_request
-    @slave.query(request).should == "\xff\xff"
-  end
-
-  it 'should sugar connect method' do
-    port, baud = "/dev/port1", 4800
-    SerialPort.should_receive(:new).with(port, baud, 8, 1, SerialPort::NONE).and_return(@sp)    
-    @sp.should_receive(:closed?).and_return(false)
-    @sp.should_receive(:close)
-    @sp.should_receive(:flow_control=).with(SerialPort::NONE)
-    ModBus::RTUClient.connect(port, baud) do |cl|
-      cl.port.should == port
-      cl.baud.should == baud
-      cl.data_bits.should == 8
-      cl.stop_bits.should == 1
-      cl.parity.should == SerialPort::NONE
-    end
-  end
-
-  it 'should have closed? method' do
-    @sp.should_receive(:closed?).and_return(false)
-    @cl.closed?.should == false
-
-    @sp.should_receive(:closed?).and_return(false)
-    @sp.should_receive(:close)
-
-    @cl.close
-
-    @sp.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
-
-  def stab_valid_request
-    request = "\x3\x0\x1\x0\x1"
-    @sp.should_receive(:write).with("\1#{request}\xd5\xca")
-    @sp.should_receive(:read).with(2).and_return("\x1\x3")
-    @sp.should_receive(:read).with(1).and_return("\x2")
-    @sp.should_receive(:read).with(4).and_return("\xff\xff\xb9\xf4")
-
-    request
-  end
-end
-

data/spec/rtu_server_spec.rb

@@ -1,30 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::RTUServer do
-  before do
-    @sp = double('SerialPort')
-    SerialPort.should_receive(:new).with('/dev/ttyS0', 4800, 7, 2, SerialPort::NONE).and_return(@sp)
-    @sp.stub(:read_timeout=)
-    @sp.should_receive(:flow_control=).with(SerialPort::NONE)
-
-    @server = ModBus::RTUServer.new('/dev/ttyS0', 4800, 1, :data_bits => 7, :stop_bits => 2)
-    @server.coils = [1,0,1,1]
-    @server.discrete_inputs = [1,1,0,0]
-    @server.holding_registers = [1,2,3,4]
-    @server.input_registers = [1,2,3,4]
-  end
-
-  it "should be valid initialized " do
-    @server.coils.should == [1,0,1,1]
-    @server.discrete_inputs.should == [1,1,0,0]
-    @server.holding_registers.should == [1,2,3,4]
-    @server.input_registers.should == [1,2,3,4]
-
-    @server.port.should == '/dev/ttyS0'
-    @server.baud.should == 4800
-    @server.data_bits.should == 7
-    @server.stop_bits.should == 2
-    @server.parity.should == SerialPort::NONE
-  end
-end

data/spec/rtu_via_tcp_client_spec.rb

@@ -1,76 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::RTUViaTCPClient do
-  describe "method 'query'" do    
-    before do 
-      @sock = double('Socket')
-      TCPSocket.should_receive(:new).with("127.0.0.1", 10002).and_return(@sock)    
-      @sock.stub(:read_timeout=)
-      @sock.stub(:flush)
-      
-      @cl = ModBus::RTUViaTCPClient.new("127.0.0.1")
-      @slave = @cl.with_slave(1)
-      @slave.read_retries = 1
-    end
-    
-    it "should ignore frame with other UID" do
-      request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
-      @sock.should_receive(:write).with("\1#{request}\xA6\x31")
-      @sock.should_receive(:read).with(2).and_return("\x2\x10")
-      @sock.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
-      lambda {@slave.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
-    end
-    
-    it "should ignored frame with incorrect CRC" do
-      request = "\x10\x0\x1\x0\x1\x2\xff\xff" 
-      @sock.should_receive(:write).with("\1#{request}\xA6\x31")
-      @sock.should_receive(:read).with(2).and_return("\x2\x10")
-      @sock.should_receive(:read).with(6).and_return("\x0\x1\x0\x1\x1C\x08")
-      lambda {@slave.query(request)}.should raise_error(ModBus::Errors::ModBusTimeout)
-    end
-    
-    it "should return value of registers"do
-      request = "\x3\x0\x1\x0\x1"
-      @sock.should_receive(:write).with("\1#{request}\xd5\xca")
-      @sock.should_receive(:read).with(2).and_return("\x1\x3")
-      @sock.should_receive(:read).with(1).and_return("\x2")
-      @sock.should_receive(:read).with(4).and_return("\xff\xff\xb9\xf4")
-      @slave.query(request).should == "\xff\xff"
-    end
-    
-    it 'should sugar connect method' do
-      ipaddr, port = '127.0.0.1', 502
-      TCPSocket.should_receive(:new).with(ipaddr, port).and_return(@sock)
-      @sock.should_receive(:closed?).and_return(false)
-      @sock.should_receive(:close)
-      ModBus::RTUViaTCPClient.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::RTUViaTCPClient.new('81.123.231.11', 1999, :connect_timeout => 0.001) }.should raise_error(ModBus::Errors::ModBusTimeout)
-  end
-end

data/spec/rtu_via_tcp_server_spec.rb

@@ -1,16 +0,0 @@
-# -*- coding: ascii
-require "rmodbus"
-
-describe ModBus::RTUViaTCPServer do
-  it "should have options :host" do
-    host = '192.168.0.1'
-    srv = ModBus::RTUViaTCPServer.new(1010, 1, :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, 1, :max_connection => 5)
-    srv.maxConnections.should eql(max_conn)
-  end
-end

data/spec/slave_spec.rb

@@ -1,55 +0,0 @@
-# -*- coding: ascii
-require 'rmodbus'
-
-describe ModBus::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

@@ -1,54 +0,0 @@
-# -*- 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