suretax 0.2.3 → 1.0.0

data/spec/lib/suretax/api/request_spec.rb

@@ -1,14 +1,13 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Suretax::Api::Request do
-
   let(:args) { suretax_valid_request_params }
   let(:api_request) { Suretax::Api::Request.new(args) }
   let(:valid_params) { valid_encoded_test_request_body }
 
-  describe 'accessors' do
+  describe "accessors" do
     {
-       business_unit: "testing",
+      business_unit: "testing",
        client_number: suretax_client_number,
        client_tracking: "track",
        data_month: "7",
@@ -20,83 +19,81 @@ describe Suretax::Api::Request do
        return_file_code: "0",
        total_revenue: "40",
        validation_key: suretax_key
-    }.each_pair do |key,value|
+    }.each_pair do |key, value|
 
       it "##{key} should return the correct value" do
-        api_request.send("#{key.to_s}=",value)
+        api_request.send("#{key}=", value)
         expect(api_request.send(key)).to eql(value)
       end
-
     end
   end
 
-  context 'configuration' do
-    it 'should use Suretax.configuration by default' do
+  context "configuration" do
+    it "should use Suretax.configuration by default" do
       req = Suretax::Api::Request.new
       expect(req.client_number).to eql(suretax_client_number)
     end
 
-    it 'should allow the default configuration to be overridden' do
-      client_number = '1122334455'
+    it "should allow the default configuration to be overridden" do
+      client_number = "1122334455"
 
-      req = Suretax::Api::Request.new({client_number: client_number})
+      req = Suretax::Api::Request.new(client_number: client_number)
 
       expect(req.client_number).to eql(client_number)
     end
   end
 
-  context 'defaults' do
-    describe '#client_number' do
-      it 'should have :client_number set to the configuration default' do
+  context "defaults" do
+    describe "#client_number" do
+      it "should have :client_number set to the configuration default" do
         req = Suretax::Api::Request.new
         expect(req.client_number).to eql(suretax_client_number)
       end
 
-      it 'should allow you to override the default' do
-        client_no = '9911991199'
-        req = Suretax::Api::Request.new({ client_number: client_no })
+      it "should allow you to override the default" do
+        client_no = "9911991199"
+        req = Suretax::Api::Request.new(client_number: client_no)
         expect(req.client_number).to eql(client_no)
       end
     end
 
-    describe '#validation_key' do
-      it 'should have :validation_key set to the configuration default' do
+    describe "#validation_key" do
+      it "should have :validation_key set to the configuration default" do
         req = Suretax::Api::Request.new
         expect(req.validation_key).to eql(suretax_key)
       end
 
-      it 'should allow you to override the default' do
-        key = '9911991199-abdce-000000000'
-        req = Suretax::Api::Request.new({ validation_key: key })
+      it "should allow you to override the default" do
+        key = "9911991199-abdce-000000000"
+        req = Suretax::Api::Request.new(validation_key: key)
         expect(req.validation_key).to eql(key)
       end
     end
 
-    describe '#return_file_code' do
+    describe "#return_file_code" do
       it 'should have :return_file_code set to "0"' do
         req = Suretax::Api::Request.new
-        expect(req.return_file_code).to eql('0')
+        expect(req.return_file_code).to eql("0")
       end
 
-      it 'should allow you to override the default' do
-        req = Suretax::Api::Request.new({ return_file_code: 'Q' })
-        expect(req.return_file_code).to eql('Q')
+      it "should allow you to override the default" do
+        req = Suretax::Api::Request.new(return_file_code: "Q")
+        expect(req.return_file_code).to eql("Q")
       end
     end
-
   end
 
-  describe '#params' do
-    it 'should return a valid parameters hash' do
+  describe "#params" do
+    it "should return a valid parameters hash" do
       expect(api_request.params).to eql(valid_params)
     end
   end
 
   describe "#submit" do
-    subject{ api_request.submit }
+    subject { api_request.submit }
     let(:api_path) { suretax_post_path }
 
-    before(:each) do 
+    before(:each) do
       stub_request(:post, "#{suretax_url}#{api_path}").to_return(
         status: 200,
         body: suretax_wrap_response(valid_test_response_body.to_json)
@@ -107,10 +104,10 @@ describe Suretax::Api::Request do
       should be_a_kind_of(Suretax::Api::Response)
     end
 
-    its('groups.size'){ should >= 1 }
+    its("groups.size") { should >= 1 }
 
     it "should have taxes" do
-      subject.groups.map(&:taxes).should_not be_empty 
+      subject.groups.map(&:taxes).should_not be_empty
     end
 
     it "should have a transaction number" do
@@ -120,15 +117,15 @@ describe Suretax::Api::Request do
   end
 
   describe "#rollback" do
-    subject{ api_request.rollback }
+    subject { api_request.rollback }
 
     context "before submitting the request" do
-      before(:each){ api_request.send(:response).should be_nil }
-      it{ should be_nil }
+      before(:each) { api_request.send(:response).should be_nil }
+      it { should be_nil }
     end
 
     context "after submitting the request" do
-      before(:each) do 
+      before(:each) do
         stub_request(:post, "#{suretax_url}#{suretax_post_path}").to_return(
           status: 200,
           body: suretax_wrap_response(valid_test_response_body.to_json)
@@ -138,62 +135,61 @@ describe Suretax::Api::Request do
 
       it "should issue a cancel request" do
         Suretax::Api::CancelRequest.should_receive(:new).
-          with(transaction:     api_request.response.transaction, 
-               client_number:   api_request.client_number, 
-               validation_key:  api_request.validation_key, 
+          with(transaction:     api_request.response.transaction,
+               client_number:   api_request.client_number,
+               validation_key:  api_request.validation_key,
                client_tracking: api_request.client_tracking).
-          and_return( double(Suretax::Api::CancelRequest, submit: true) )
+          and_return(double(Suretax::Api::CancelRequest, submit: true))
         subject
       end
     end
   end
 
-  describe '#data_month' do
+  describe "#data_month" do
     subject { Suretax::Api::Request.new(options) }
 
-    context 'when the value is supplied' do
-      let(:options) { { data_month: '04' } }
-      its(:data_month) { should eql '04' }
+    context "when the value is supplied" do
+      let(:options) { { data_month: "04" } }
+      its(:data_month) { should eql "04" }
     end
 
-    context 'when the value is not supplied' do
-      let(:options) { { } }
+    context "when the value is not supplied" do
+      let(:options) { {} }
 
-      context 'and Suretax is configured for production' do
+      context "and Suretax is configured for production" do
         before(:each) { Suretax.configuration.stub(:test?).and_return(false) }
-        its(:data_month) { should eql Date.today.strftime('%m') }
+        its(:data_month) { should eql Date.today.strftime("%m") }
       end
 
-      context 'and Suretax is not configured for production' do
+      context "and Suretax is not configured for production" do
         before(:each) { Suretax.configuration.stub(:test?).and_return(true) }
-        its(:data_month) { should eql Date.today.prev_month.strftime('%m') }
+        its(:data_month) { should eql Date.today.prev_month.strftime("%m") }
       end
     end
   end
 
-  describe '#data_year' do
+  describe "#data_year" do
     subject { Suretax::Api::Request.new(options) }
 
-    context 'when the value is supplied' do
-      let(:options) {  { data_year: '2012', data_month: '01' } }
-      its(:data_year)  { should eql '2012' }
-      its(:data_month) { should eql '01' }
+    context "when the value is supplied" do
+      let(:options) {  { data_year: "2012", data_month: "01" } }
+      its(:data_year)  { should eql "2012" }
+      its(:data_month) { should eql "01" }
     end
 
-    context 'when the value is not supplied' do
-      before(:each) { Date.stub(:today) { Date.new(2014, 01, 01) } }
-      let(:options) { { } }
+    context "when the value is not supplied" do
+      before(:each) { Date.stub(:today) { Date.new(2014, 0o1, 0o1) } }
+      let(:options) { {} }
 
-      context 'and Suretax is configured for production' do
+      context "and Suretax is configured for production" do
         before(:each) { Suretax.configuration.stub(:test?).and_return(false) }
-        its(:data_year) { should eql Date.today.strftime('%Y') }
+        its(:data_year) { should eql Date.today.strftime("%Y") }
       end
 
-      context 'and Suretax is not configured for production' do
+      context "and Suretax is not configured for production" do
         before(:each) { Suretax.configuration.stub(:test?).and_return(true) }
-        its(:data_year) { should eql Date.today.prev_month.strftime('%Y') }
+        its(:data_year) { should eql Date.today.prev_month.strftime("%Y") }
       end
     end
   end
 end
-

data/spec/lib/suretax/api/request_validations_spec.rb

@@ -1,7 +1,6 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe "Suretax API Request Validations" do
-
   let(:request) do
     Suretax::Api::Request.new(suretax_valid_request_params)
   end
@@ -16,158 +15,158 @@ describe "Suretax API Request Validations" do
     context "when invalid" do
       it "shows no errors" do
         item = Suretax::Api::RequestItem.new(suretax_valid_request_item_params)
-        item.customer_number = 'a' * 9
-        item.regulatory_code = 11111
+        item.customer_number = "a" * 9
+        item.regulatory_code = 11_111
         request.items = [item]
 
         expect(request.errors.any?).to eq true
         expect(request.errors.messages).to \
-          eq([%Q{Invalid items: ["Invalid customer_number: aaaaaaaaa, Invalid regulatory_code: 11111"]}])
+          eq([%(Invalid items: ["Invalid customer_number: aaaaaaaaa, Invalid regulatory_code: 11111"])])
       end
     end
   end
 
-  describe '#client_number' do
-    context 'when present' do
-      it 'can be ten characters or less' do
-        request.client_number = '1234567890'
+  describe "#client_number" do
+    context "when present" do
+      it "can be ten characters or less" do
+        request.client_number = "1234567890"
         expect(request.errors.any?).to eq false
 
-        request.client_number = '12345678901'
+        request.client_number = "12345678901"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid client_number: 12345678901}]
+        expect(request.errors.messages).to eq [%(Invalid client_number: 12345678901)]
       end
 
-      it 'must be a number' do
-        request.client_number = '1'
+      it "must be a number" do
+        request.client_number = "1"
         expect(request.errors.any?).to eq false
 
-        request.client_number = 'abcdefghij'
+        request.client_number = "abcdefghij"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid client_number: abcdefghij}]
+        expect(request.errors.messages).to eq [%(Invalid client_number: abcdefghij)]
       end
     end
 
-    context 'when absent' do
-      it 'should fail validation' do
+    context "when absent" do
+      it "should fail validation" do
         request.client_number = nil
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid client_number: nil}]
+        expect(request.errors.messages).to eq [%(Invalid client_number: nil)]
       end
     end
   end
 
-  describe '#business_unit' do
-    context 'when present' do
-      it 'can be blank' do
+  describe "#business_unit" do
+    context "when present" do
+      it "can be blank" do
         request.business_unit = nil
         expect(request.errors.any?).to eq false
 
-        request.business_unit = ''
+        request.business_unit = ""
         expect(request.errors.any?).to eq false
       end
 
-      it 'can be 20 characters or less' do
-        request.business_unit = 'a' * 5
+      it "can be 20 characters or less" do
+        request.business_unit = "a" * 5
         expect(request.errors.any?).to eq false
 
-        request.business_unit = 'a' * 20
+        request.business_unit = "a" * 20
         expect(request.errors.any?).to eq false
 
-        request.business_unit = 'a' * 21
+        request.business_unit = "a" * 21
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid business_unit: #{'a' * 21}}]
+        expect(request.errors.messages).to eq [%(Invalid business_unit: #{'a' * 21})]
       end
 
-      it 'must be alphanumeric' do
-        request.business_unit = 'aa124'
+      it "must be alphanumeric" do
+        request.business_unit = "aa124"
         expect(request.errors.any?).to eq false
 
-        request.business_unit = 'a_34'
+        request.business_unit = "a_34"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid business_unit: a_34}]
+        expect(request.errors.messages).to eq [%(Invalid business_unit: a_34)]
       end
     end
 
-    context 'when absent' do
-      it 'should pass validation' do
+    context "when absent" do
+      it "should pass validation" do
         request.business_unit = nil
         expect(request.errors.any?).to eq false
       end
     end
   end
 
-  describe '#validation_key' do
-    context 'when present' do
-      it 'must be a maximum of 36 characters' do
-        request.validation_key = 'a' * 36
+  describe "#validation_key" do
+    context "when present" do
+      it "must be a maximum of 36 characters" do
+        request.validation_key = "a" * 36
         expect(request.errors.any?).to eq false
 
-        request.validation_key = 'a' * 37
+        request.validation_key = "a" * 37
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid validation_key: #{'a' * 37}}]
+        expect(request.errors.messages).to eq [%(Invalid validation_key: #{'a' * 37})]
       end
     end
 
-    context 'when absent' do
-      it 'should fail validation' do
+    context "when absent" do
+      it "should fail validation" do
         request.validation_key = nil
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid validation_key: nil}]
+        expect(request.errors.messages).to eq [%(Invalid validation_key: nil)]
       end
     end
   end
 
-  describe '#data_year' do
-    context 'when present' do
-      it 'must be a number' do
-        request.data_year = 'b' * 4
+  describe "#data_year" do
+    context "when present" do
+      it "must be a number" do
+        request.data_year = "b" * 4
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid data_year: #{'b' * 4}}]
+        expect(request.errors.messages).to eq [%(Invalid data_year: #{'b' * 4})]
 
-        request.data_year = '-' * 4
+        request.data_year = "-" * 4
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid data_year: #{'-' * 4}}]
+        expect(request.errors.messages).to eq [%(Invalid data_year: #{'-' * 4})]
 
-        request.data_year = '2014'
+        request.data_year = "2014"
         expect(request.errors.any?).to eq false
       end
 
-      it 'must be exactly four digits' do
-        request.data_year = '2014'
+      it "must be exactly four digits" do
+        request.data_year = "2014"
         expect(request.errors.any?).to eq false
 
-        request.data_year = '20120'
+        request.data_year = "20120"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid data_year: 20120}]
+        expect(request.errors.messages).to eq [%(Invalid data_year: 20120)]
 
-        request.data_year = '201'
+        request.data_year = "201"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid data_year: 201}]
+        expect(request.errors.messages).to eq [%(Invalid data_year: 201)]
       end
 
-      it 'must be in the range 1990-2050' do
-        request.data_year = '1989'
+      it "must be in the range 1990-2050" do
+        request.data_year = "1989"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid data_year: 1989}]
+        expect(request.errors.messages).to eq [%(Invalid data_year: 1989)]
 
-        request.data_year = '2051'
+        request.data_year = "2051"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid data_year: 2051}]
+        expect(request.errors.messages).to eq [%(Invalid data_year: 2051)]
       end
     end
 
-    context 'when absent' do
-      it 'fails validation' do
+    context "when absent" do
+      it "fails validation" do
         request.data_year = nil
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid data_year: nil}]
+        expect(request.errors.messages).to eq [%(Invalid data_year: nil)]
       end
     end
   end
 
-  describe '#data_month' do
-    context 'when present' do
+  describe "#data_month" do
+    context "when present" do
       it "must allow all valid month numbers" do
         (1..12).each do |month_number|
           request.data_month = month_number.to_s
@@ -185,199 +184,198 @@ describe "Suretax API Request Validations" do
         end
       end
 
-      it 'must not allow invalid months' do
-        request.data_month = '13'
+      it "must not allow invalid months" do
+        request.data_month = "13"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid data_month: 13}]
+        expect(request.errors.messages).to eq [%(Invalid data_month: 13)]
       end
     end
 
-    context 'when absent' do
-      it 'should fail validation' do
+    context "when absent" do
+      it "should fail validation" do
         request.data_month = nil
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid data_month: nil}]
+        expect(request.errors.messages).to eq [%(Invalid data_month: nil)]
       end
     end
   end
 
-  describe '#total_revenue' do
-    context 'when present' do
-      it 'can only be digits and the minus symbol' do
-        request.total_revenue = 'abcdefghi.jklm'
+  describe "#total_revenue" do
+    context "when present" do
+      it "can only be digits and the minus symbol" do
+        request.total_revenue = "abcdefghi.jklm"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid total_revenue: abcdefghi.jklm}]
+        expect(request.errors.messages).to eq [%(Invalid total_revenue: abcdefghi.jklm)]
 
-        request.total_revenue = '+1234'
+        request.total_revenue = "+1234"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid total_revenue: +1234}]
+        expect(request.errors.messages).to eq [%(Invalid total_revenue: +1234)]
       end
 
-      it 'can have up to four decimal places' do
-        request.total_revenue = '123456789.1234'
+      it "can have up to four decimal places" do
+        request.total_revenue = "123456789.1234"
         expect(request.errors.any?).to eq false
 
-        request.total_revenue = '123456789.1'
+        request.total_revenue = "123456789.1"
         expect(request.errors.any?).to eq false
       end
 
-      it 'must not have more than four decimal places' do
-        request.total_revenue = '123456789.12345'
+      it "must not have more than four decimal places" do
+        request.total_revenue = "123456789.12345"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid total_revenue: 123456789.12345}]
+        expect(request.errors.messages).to eq [%(Invalid total_revenue: 123456789.12345)]
       end
 
-      context 'and when the value is positive' do
-        it 'should have no symbol' do
-          request.total_revenue = '+23456789.1234'
+      context "and when the value is positive" do
+        it "should have no symbol" do
+          request.total_revenue = "+23456789.1234"
           expect(request.errors.any?).to eq true
-          expect(request.errors.messages).to eq [%Q{Invalid total_revenue: +23456789.1234}]
+          expect(request.errors.messages).to eq [%(Invalid total_revenue: +23456789.1234)]
         end
 
-        it 'can have up to nine positions to the left of the decimal' do
-          request.total_revenue = '123456789.1234'
+        it "can have up to nine positions to the left of the decimal" do
+          request.total_revenue = "123456789.1234"
           expect(request.errors.any?).to eq false
 
-          request.total_revenue = '1.1234'
+          request.total_revenue = "1.1234"
           expect(request.errors.any?).to eq false
 
-          request.total_revenue = '1234567890.1234'
+          request.total_revenue = "1234567890.1234"
           expect(request.errors.any?).to eq true
-          expect(request.errors.messages).to eq [%Q{Invalid total_revenue: 1234567890.1234}]
+          expect(request.errors.messages).to eq [%(Invalid total_revenue: 1234567890.1234)]
         end
 
-        it 'can be a simple integer' do
-          request.total_revenue = '1'
+        it "can be a simple integer" do
+          request.total_revenue = "1"
           expect(request.errors.any?).to eq false
         end
-
       end
 
-      context 'and when the value is negative' do
+      context "and when the value is negative" do
         it 'should have a "minus" symbol in the first position' do
-          request.total_revenue = '-23456789.1234'
+          request.total_revenue = "-23456789.1234"
           expect(request.errors.any?).to eq false
         end
 
-        it 'must have nine positions to the left of the decimal' do
-          request.total_revenue = '-23456789.1234'
+        it "must have nine positions to the left of the decimal" do
+          request.total_revenue = "-23456789.1234"
           expect(request.errors.any?).to eq false
         end
 
-        it 'must not have more than nine positions to the left of the decimal' do
-          request.total_revenue = '-234567890.1234'
+        it "must not have more than nine positions to the left of the decimal" do
+          request.total_revenue = "-234567890.1234"
           expect(request.errors.any?).to eq true
-          expect(request.errors.messages).to eq [%Q{Invalid total_revenue: -234567890.1234}]
+          expect(request.errors.messages).to eq [%(Invalid total_revenue: -234567890.1234)]
         end
       end
     end
 
-    context 'when absent' do
-      it 'should fail validation' do
+    context "when absent" do
+      it "should fail validation" do
         request.total_revenue = nil
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid total_revenue: nil}]
+        expect(request.errors.messages).to eq [%(Invalid total_revenue: nil)]
       end
     end
   end
 
-  describe '#client_tracking' do
-    context 'when present' do
-      it 'must not be longer than 100 characters' do
-        request.client_tracking = 'a' * 101
+  describe "#client_tracking" do
+    context "when present" do
+      it "must not be longer than 100 characters" do
+        request.client_tracking = "a" * 101
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid client_tracking: #{'a' * 101}}]
+        expect(request.errors.messages).to eq [%(Invalid client_tracking: #{'a' * 101})]
       end
     end
 
-    context 'when absent' do
-      it 'should pass validation' do
+    context "when absent" do
+      it "should pass validation" do
         request.client_tracking = nil
         expect(request.errors.any?).to eq false
       end
     end
   end
 
-  describe '#return_file_code' do
-    context 'when present' do
-      it 'must be a valid code' do
+  describe "#return_file_code" do
+    context "when present" do
+      it "must be a valid code" do
         request.return_file_code = 0
         expect(request.errors.any?).to eq false
 
-        request.return_file_code = 'Q'
+        request.return_file_code = "Q"
         expect(request.errors.any?).to eq false
       end
 
-      it 'cannot be any other value' do
-        request.return_file_code = 'a'
+      it "cannot be any other value" do
+        request.return_file_code = "a"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid return_file_code: a}]
+        expect(request.errors.messages).to eq [%(Invalid return_file_code: a)]
 
         request.return_file_code = 1
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid return_file_code: 1}]
+        expect(request.errors.messages).to eq [%(Invalid return_file_code: 1)]
 
-        request.return_file_code = '_'
+        request.return_file_code = "_"
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid return_file_code: _}]
+        expect(request.errors.messages).to eq [%(Invalid return_file_code: _)]
       end
     end
 
-    context 'when absent' do
-      it 'should fail validation' do
+    context "when absent" do
+      it "should fail validation" do
         request.return_file_code = nil
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid return_file_code: nil}]
+        expect(request.errors.messages).to eq [%(Invalid return_file_code: nil)]
       end
     end
   end
 
-  describe '#response_group' do
-    context 'when present' do
+  describe "#response_group" do
+    context "when present" do
       it "must be a valid code" do
-        %w{00 01 02 03}.each do |code|
+        %w[00 01 02 03].each do |code|
           request.response_group = code
           expect(request.errors.any?).to eq false
         end
 
-        %w{a 04 _}.each do |wrong_value|
+        %w[a 04 _].each do |wrong_value|
           request.response_group = wrong_value
           expect(request.errors.any?).to eq true
-          expect(request.errors.messages).to eq [%Q{Invalid response_group: #{wrong_value}}]
+          expect(request.errors.messages).to eq [%(Invalid response_group: #{wrong_value})]
         end
       end
     end
 
-    context 'when absent' do
-      it 'should fail validation' do
+    context "when absent" do
+      it "should fail validation" do
         request.response_group = nil
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid response_group: nil}]
+        expect(request.errors.messages).to eq [%(Invalid response_group: nil)]
       end
     end
   end
 
-  describe '#response_type' do
-    context 'when present' do
+  describe "#response_type" do
+    context "when present" do
       it "must be a valid code combination'" do
-        %w{D1 D9 S1 S9}.each do |type|
+        %w[D1 D9 S1 S9].each do |type|
           request.response_type = type
           expect(request.errors.any?).to eq false
         end
 
-        %w{a D0 S10 _}.each do |bad_type|
+        %w[a D0 S10 _].each do |bad_type|
           request.response_type = bad_type
           expect(request.errors.any?).to eq true
-          expect(request.errors.messages).to eq [%Q{Invalid response_type: #{bad_type}}]
+          expect(request.errors.messages).to eq [%(Invalid response_type: #{bad_type})]
         end
       end
     end
 
-    context 'when absent' do
-      it 'should fail validation' do
+    context "when absent" do
+      it "should fail validation" do
         request.response_type = nil
         expect(request.errors.any?).to eq true
-        expect(request.errors.messages).to eq [%Q{Invalid response_type: nil}]
+        expect(request.errors.messages).to eq [%(Invalid response_type: nil)]
       end
     end
   end