DEV Community: Alexander Spitsyn

Rewind Files Before Reading

Alexander Spitsyn — Wed, 18 Sep 2019 20:50:32 +0000

Suppose you have a form with a file input and you need to forward that file to an external service through your Rails app. Params will look like this:

{ "file"=> #<ActionDispatch::Http::UploadedFile:0x00007fce9a8af140 @tempfile=#<Tempfile:/path/to/the/file.xlsx>, ... > }

The external service can not be reached for the first time sometimes, so you decided to set some retry count.

retry_count = 5
while retry_count > 0
    begin
        HTTPClient.new.post(url, params, headers)
    rescue ExternalServiceUnavailable => e
        retry_count -= 1
    end
end

The code above uses HTTPClient gem for making http requests and it will raise the following error in case there will be at least one retry:
ArgumentError: Illegal size value: #size returns 154139 but cannot read
The thing is that HTTPClient uses IO#read to read the file by chunks for making POST request. The lineno pointer reaches the end of the file after read, and you can not read bytes from the I/O stream anymore:

params['file'].tempfile.eof? # => true

To fix that, use IO#rewind – it positions IO to the beginning of input, resetting lineno to zero. Just add checking the file for eof before each request and rewind it if needed:

retry_count = 5
while retry_count > 0
    begin
        params['file'].tempfile.rewind if params['file'].tempfile.eof? # check eof
        HTTPClient.new.post(url, params, headers)
    rescue ExternalServiceUnavailable => e
        retry_count -= 1
    end
end

Handling IP addresses using PostgreSQL

Alexander Spitsyn — Tue, 03 Sep 2019 07:52:22 +0000

PostgreSQL provides a inet and cidr datatypes for storing net addresses and proceed operations with them.

Host address and it's subnet can be stored with inet, while cidr can contain only network address:

select inet '192.168.0.1/24';
      inet
----------------
 192.168.0.1/24

select cidr '192.168.0.0/24'; -- valid cidr
      cidr
----------------
 192.168.0.0/24

select cidr '192.168.0.1/24'; -- invalid: cidr must not be a host address
ERROR:  invalid cidr value: "192.168.0.1/24"
LINE 1: select cidr '192.168.0.1/24';
                    ^
DETAIL:  Value has bits set to right of mask.

In case there's no number after slash in cidr address the netmask is to equal 32:

select cidr('127.0.0.1');
     cidr
--------------
 127.0.0.1/32

The value above represents a subnet address, while the same value passed to inet represents a host:

select inet('127.0.0.1');
   inet
-----------
 127.0.0.1

Checking inclusion or equality can be performed with >>= and <<= operators:

select inet '192.168.0.1/24' >>= inet '192.168.0.0'; -- returns true
select cidr '192.168.0.0/24' >>= inet '192.168.0.0/12'; -- returns false
select cidr '192.168.0.0' >>= cidr '192.168.0.0'; -- returns true

And getting a netmask by a net address can be performed with netmask:

select netmask(inet('192.168.0.0/24')); -- returns 255.255.255.0
select netmask(cidr('127.0.0.1')); -- returns 255.255.255.255

Determining class of an object with case equality operator (===)

Alexander Spitsyn — Mon, 02 Sep 2019 16:59:53 +0000

Case equality operator (or triple equals, ===) in Ruby returns true if the passed class is in the ancestors list of the passed object's class:

1.class.ancestors # [Integer, Numeric, Object, ...]
Numeric === 1 # true
Object === 1 # true

So it can be used for determining object's class:

String === 'abc' # true
'abc'.class #=> String

In cases above the case equality operator works like #kind_of? (or #is_a?):

1.kind_of?(Integer) # true
1.is_a?(Numeric) # true

The classes above has different implementations of === operator, that's why the results of comparison are different:

String.===('abc') # the same as String === 'abc'

Also it means that order of the arguments is important:

1 === Integer # false

Testing external API integration with VCR gem

Alexander Spitsyn — Mon, 02 Sep 2019 13:19:24 +0000

Suppose your application connects to an external service via API and you have a wrapper for this API that handles and parses response. The VCR gem gives you ability to store parsed response in a special format (cassetes). VCR makes a real request to the API for the first test run and writes it's response to the cassete for next test runnings.

First you need to set VCR configuration:

VCR.configure do |config|
  config.cassette_library_dir = "spec/vcr_cassettes"
  config.hook_into :webmock
end

And then write specs like the following:

RSpec.describe ExternalService do
  describe '#new_order' do
    let(:params) { { foo: 'bar' } }

    it 'creates new order' do
      VCR.use_cassette("external_service") do
        result = subject.new_order(params) # makes HTTP POST to an external service

        expect(result.successful?).to be_truthy
        expect(result.data).to have_key('order_id')
      end
    end
  end
end

See more details on the official page of the gem.