suretax 0.1.0

data/lib/suretax/response.rb

@@ -0,0 +1,70 @@
+require 'json'
+
+module Suretax
+
+  class Response
+    attr_reader :response, :body, :status, :api
+
+    def initialize(api_response)
+      @response = api_response
+      sanitized_body = remove_xml_brackets(api_response.body)
+      if sanitized_body == 'invalid request'
+        @body = sanitized_body
+        @status = 400
+        @api = nil
+        log_response
+
+        return self
+      end
+      @body = JSON.parse(sanitized_body)
+      @api = Api::Response.new(@body)
+      @status = map_response_code_to_http_status(api.status)
+
+      log_response
+    end
+
+    def success?
+      status == 200
+    end
+
+    private
+
+    def extract_json_from_urlencoded_string_regex
+      # http://rubular.com/r/0w73fy4Ldk
+      /\A<\?xml.*<string[^>]+>(?<json_string>.+)<\/string>\z/m
+    end
+
+    def remove_xml_brackets(response_string)
+      if matches = response_string.match(extract_json_from_urlencoded_string_regex)
+        matches['json_string']
+      else
+        response_string
+      end
+    end
+
+    def map_response_code_to_http_status(api_status_code)
+      case api_status_code
+      when '9999'
+        200
+      when '9001'
+        409
+      else
+        400
+      end
+    end
+
+    def log_response
+      logger.debug "\nSureTax Response Received:\n#{@body.inspect}" if logger
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    def configuration
+      Suretax.configuration
+    end
+
+  end
+
+end

data/lib/suretax/version.rb

@@ -0,0 +1,3 @@
+module Suretax
+  VERSION = "0.1.0"
+end

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Suretax::Api::Group do
+
+  let(:group) { Suretax::Api::Group.new(group_hash) }
+
+  context 'with a v01 API response' do
+    let(:group_hash) { valid_test_response_body['GroupList'].first }
+
+    it 'should have a state' do
+      expect(group.state).to eql('CA')
+    end
+
+    it 'should have an invoice number' do
+      expect(group.invoice).to eql('1')
+    end
+
+    it 'should have a customer number' do
+      expect(group.customer).to eql('000000007')
+    end
+
+    it 'should have a list of taxes' do
+      expect(group.taxes.count).to eql(8)
+    end
+  end
+
+  context 'with a v03 API response' do
+    let(:group_hash) { valid_v03_response_body['GroupList'].first }
+
+    it 'should have a state' do
+      expect(group.state).to eql('CA')
+    end
+
+    it 'should have an invoice number' do
+      expect(group.invoice).to eql('1')
+    end
+
+    it 'should have a line number' do
+      expect(group.line).to eql('1')
+    end
+
+    it 'should have a customer number' do
+      expect(group.customer).to eql('000000007')
+    end
+
+    it 'should have a list of taxes' do
+      expect(group.taxes.count).to eql(8)
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Suretax::Api::RequestItem do
+
+  let(:args) { suretax_valid_request_item_params }
+  let(:subject) { Suretax::Api::RequestItem.new(args) }
+
+  describe '#tax_exemption_codes' do
+
+    it 'should have two codes' do
+      expect(subject.tax_exemption_codes.count).to eql(2)
+    end
+  end
+
+  describe '#params' do
+    {
+      bill_to_number: "8585260000",
+      customer_number: "000000007",
+      invoice_number: "1",
+      line_number: "1",
+      orig_number: "8585260000",
+      p_to_p_plus_four: "",
+      p_to_p_zipcode: "",
+      plus_four: "",
+      regulatory_code: "99",
+      revenue: "40",
+      sales_type_code: "R",
+      seconds: "55",
+      tax_included_code: "0",
+      tax_situs_rule: "01",
+      term_number: "8585260000",
+      trans_date: "2013-12-01T00:00:00",
+      trans_type_code: "010101",
+      unit_type: "00",
+      units: "1",
+      zipcode: ""
+    }.each_pair do |key,value|
+      it "##{key} should return the correct value" do
+        subject.send("#{key.to_s}=",value)
+        expect(subject.send(key)).to eql(value)
+      end
+    end
+  end
+
+  describe '#params' do
+    let(:valid_params) do
+      valid_encoded_test_request_body['ItemList'].first
+    end
+
+    it 'should return a valid parameters hash' do
+      expect(subject.params).to eql(valid_params)
+    end
+  end
+end

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

@@ -0,0 +1,237 @@
+require 'spec_helper'
+
+describe "Suretax API Request Item Validations" do
+
+  let(:request_item) do
+    Suretax::Api::RequestItem.new(suretax_valid_request_item_params)
+  end
+
+  describe '#customer_number' do
+    it 'should not be valid when it is not a number' do
+      request_item.customer_number = ''
+
+      expect(request_item.errors.any?).to eq true
+      expect(request_item.errors.messages).to eq [%Q{Invalid customer_number: ''}]
+    end
+
+    it 'should not be valid when the length is wrong' do
+      request_item.customer_number = '1' * 11
+
+      expect(request_item.errors.any?).to eq true
+      expect(request_item.errors.messages).to eq [%Q{Invalid customer_number: #{'1' * 11}}]
+    end
+
+    it 'should not be valid when it is not a number' do
+      request_item.customer_number = 'a' * 9
+
+      expect(request_item.errors.any?).to eq true
+      expect(request_item.errors.messages).to eq [%Q{Invalid customer_number: #{'a' * 9}}]
+    end
+
+    it 'should be valid when it is a nine-digit number' do
+      expect(request_item.errors.any?).to eq false
+    end
+  end
+
+  describe '#invoice_number' do
+    %w{123 a1234 abcdef}.each do |value|
+      it "can be '#{value}'" do
+        request_item.invoice_number = value
+
+        expect(request_item.errors.any?).to eq false
+      end
+    end
+
+    it 'cannot be longer than 20 characters' do
+      request_item.invoice_number = '1' * 21
+
+      expect(request_item.errors.any?).to eq true
+      expect(request_item.errors.messages).to eq [%Q{Invalid invoice_number: #{'1' * 21}}]
+    end
+
+    it 'can be blank' do
+      request_item.invoice_number = nil
+
+      expect(request_item.errors.any?).to eq false
+    end
+  end
+
+  describe '#line_number' do
+    it 'must not be more than 20 characters in length' do
+      request_item.line_number = '1' * 21
+
+      expect(request_item.errors.any?).to eq true
+      expect(request_item.errors.messages).to eq [%Q{Invalid line_number: #{'1' * 21}}]
+    end
+
+    it 'can be blank' do
+      request_item.line_number = nil
+
+      expect(request_item.errors.any?).to eq false
+    end
+
+    %w{1 40 580 12345678901234567890}.each do |number|
+      it "can be '#{number}'" do
+        request_item.line_number = number
+
+        expect(request_item.errors.any?).to eq false
+      end
+    end
+
+    %w{a D0 S10 _}.each do |bad_content|
+      it "cannot be '#{bad_content}'" do
+        request_item.line_number = bad_content
+
+        expect(request_item.errors.any?).to eq true
+        expect(request_item.errors.messages).to eq [%Q{Invalid line_number: #{bad_content}}]
+      end
+    end
+  end
+
+  context 'phone number fields' do
+    %w{orig_number term_number bill_to_number}.each do |phone_method|
+
+      describe "##{phone_method}" do
+        it_should_behave_like 'optional phone number' do
+          let(:subject) { phone_method }
+        end
+      end
+
+    end
+  end
+
+  describe '#tax_situs_rule' do
+    it 'must be present' do
+      request_item.tax_situs_rule = nil
+
+      expect(request_item.errors.any?).to eq true
+      expect(request_item.errors.messages).to eq [%Q{Invalid tax_situs_rule: nil}]
+    end
+
+    %w{01 02 03 04 05 06 07 14}.each do |number|
+      it "can be '#{number}'" do
+        request_item.tax_situs_rule = number
+
+        expect(request_item.errors.any?).to eq false
+      end
+    end
+
+    %w{a D0 S10 _}.each do |bad_content|
+      it "cannot be '#{bad_content}'" do
+        request_item.tax_situs_rule = bad_content
+
+        expect(request_item.errors.any?).to eq true
+        expect(request_item.errors.messages).to eq [%Q{Invalid tax_situs_rule: #{bad_content}}]
+      end
+    end
+  end
+
+  describe '#trans_type_code' do
+    context 'when present' do
+      it 'should pass validation' do
+        request_item.trans_type_code = '010101'
+
+        expect(request_item.errors.any?).to eq false
+      end
+    end
+
+    context 'when absent' do
+      it 'should fail validation' do
+        request_item.trans_type_code = nil
+
+        expect(request_item.errors.any?).to eq true
+        expect(request_item.errors.messages).to eq [%Q{Invalid trans_type_code: nil}]
+      end
+    end
+  end
+
+  describe '#sales_type_code' do
+    context 'when present' do
+      it 'should allow valid codes' do
+        %w{R B I L}.each do |code|
+          request_item.sales_type_code = code
+
+          expect(request_item.errors.any?).to eq false
+        end
+      end
+
+      it 'should not allow invalid codes' do
+        %w{A X Y Z}.each do |code|
+          request_item.sales_type_code = code
+
+          expect(request_item.errors.any?).to eq true
+          expect(request_item.errors.messages).to eq [%Q{Invalid sales_type_code: #{code}}]
+        end
+      end
+    end
+
+    context 'when absent' do
+      it 'should fail validation' do
+        request_item.sales_type_code = nil
+
+        expect(request_item.errors.any?).to eq true
+        expect(request_item.errors.messages).to eq [%Q{Invalid sales_type_code: nil}]
+      end
+    end
+  end
+
+  describe '#regulatory_code' do
+    context 'when present' do
+      it 'should allow valid codes' do
+        %w{00 01 02 03 04 05 99}.each do |code|
+          request_item.regulatory_code = code
+
+          expect(request_item.errors.any?).to eq false
+        end
+      end
+
+      it 'should not allow invalid codes' do
+        %w{44 77 4 f -}.each do |code|
+          request_item.regulatory_code = code
+
+          expect(request_item.errors.any?).to eq true
+          expect(request_item.errors.messages).to eq [%Q{Invalid regulatory_code: #{code}}]
+        end
+      end
+    end
+
+    context 'when absent' do
+      it 'should fail validation' do
+        request_item.regulatory_code = nil
+
+        expect(request_item.errors.any?).to eq true
+        expect(request_item.errors.messages).to eq [%Q{Invalid regulatory_code: nil}]
+      end
+    end
+  end
+
+  describe '#tax_exemption_codes' do
+    context 'when present' do
+      context 'and the list has content' do
+        it 'should pass validation' do
+          request_item.tax_exemption_codes = ['00']
+
+          expect(request_item.errors.any?).to eq false
+        end
+      end
+
+      context 'and the list is empty' do
+        it 'should fail validation' do
+          request_item.tax_exemption_codes = []
+
+          expect(request_item.errors.any?).to eq true
+          expect(request_item.errors.messages).to eq [%Q{Invalid tax_exemption_codes: []}]
+        end
+      end
+    end
+
+    context 'when absent' do
+      it 'should fail validation' do
+        request_item.tax_exemption_codes = nil
+
+        expect(request_item.errors.any?).to eq true
+        expect(request_item.errors.messages).to eq [%Q{Invalid tax_exemption_codes: nil}]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+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
+    {
+       business_unit: "testing",
+       client_number: suretax_client_number,
+       client_tracking: "track",
+       data_month: "7",
+       data_year: "2013",
+       industry_exemption: "",
+       response_group: "03",
+       response_type: "D6",
+       return_file_code: "0",
+       total_revenue: "40",
+       validation_key: suretax_key
+    }.each_pair do |key,value|
+
+      it "##{key} should return the correct value" do
+        api_request.send("#{key.to_s}=",value)
+        expect(api_request.send(key)).to eql(value)
+      end
+
+    end
+  end
+
+  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'
+
+      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
+        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 })
+        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
+        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 })
+        expect(req.validation_key).to eql(key)
+      end
+    end
+
+    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')
+      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')
+      end
+    end
+
+  end
+
+  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 }
+    let(:api_path) { suretax_post_path }
+
+    before(:each) do 
+      stub_request(:post, "#{suretax_url}#{api_path}").to_return(
+        status: 200,
+        body: suretax_wrap_response(valid_test_response_body.to_json)
+      )
+    end
+
+    it "should return a Suretax::Api::Response" do
+      should be_a_kind_of(Suretax::Api::Response)
+    end
+
+    its('groups.size'){ should >= 1 }
+
+    it "should have taxes" do
+      subject.groups.map(&:taxes).should_not be_empty 
+    end
+
+    it "should have a transaction number" do
+      subject.transaction.should_not be_nil
+      subject.transaction.size.should_not be_zero
+    end
+  end
+
+  describe "#rollback" do
+    subject{ api_request.rollback }
+
+    context "before submitting the request" do
+      before(:each){ api_request.send(:response).should be_nil }
+      it{ should be_nil }
+    end
+
+    context "after submitting the request" 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)
+        )
+        api_request.submit
+      end
+
+      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, 
+               client_tracking: api_request.client_tracking).
+          and_return( double(Suretax::Api::CancelRequest, submit: true) )
+        subject
+      end
+    end
+  end
+
+  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' }
+    end
+
+    context 'when the value is not supplied' do
+      let(:options) { { } }
+
+      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') }
+      end
+
+      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') }
+      end
+    end
+  end
+
+  describe '#data_year' do
+    subject { Suretax::Api::Request.new(options) }
+
+    context 'when the value is supplied' do
+      let(:options) { { data_year: '2012' } }
+      its(:data_year) { should eql '2012' }
+    end
+
+    context 'when the value is not supplied' do
+      before(:each) { Date.stub(:today) { Date.new(2014, 01, 01) } }
+      let(:options) { { } }
+
+      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') }
+      end
+
+      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') }
+      end
+    end
+  end
+end
+