vsafe-ruby 0.2.2

data/spec/vsafe/config_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "vsafe/config"
+
+RSpec.describe VSafe::Config do
+  describe ".new" do
+    it "sets default configs" do
+      config = VSafe::Config.new
+
+      expect(config.sandbox).to eq(true)
+      expect(config.request_timeout).to be_a(Fixnum)
+      expect(config.url).not_to be_empty
+    end
+  end
+end

data/spec/vsafe/cvn_result_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+require "vsafe/cvn_result"
+
+RSpec.describe VSafe::CvnResult do
+  describe ".new" do
+    let(:code) { 1 }
+
+    it "sets the code" do
+      expect(VSafe::CvnResult.new(code.to_s).code).to eq(code)
+    end
+  end
+end

data/spec/vsafe/payment_status_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+require "vsafe/payment_status"
+
+RSpec.describe VSafe::PaymentStatus do
+  describe ".new" do
+    let(:code) { 1 }
+
+    it "sets the code" do
+      expect(VSafe::PaymentStatus.new(code.to_s).code).to eq(code)
+    end
+  end
+end

data/spec/vsafe/request_error_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+require "vsafe/request_error"
+
+RSpec.describe VSafe::RequestError do
+  describe ".new" do
+    let(:response) { double }
+
+    it "sets response" do
+      expect(VSafe::RequestError.new(response).response).to eq(response)
+    end
+  end
+end

data/spec/vsafe/response_error_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "vsafe/response_error"
+
+RSpec.describe VSafe::ResponseError do
+  let(:response_body) {
+    {
+      "ResponseCode" => "1",
+      "ResponseText" => "text"
+    }
+  }
+  describe ".new" do
+    it "initializes fine" do
+      expect { VSafe::ResponseError.new(response_body) }.to_not raise_error
+    end
+  end
+
+  describe "#code" do
+    it "returns code" do
+      expect(VSafe::ResponseError.new(response_body).code).to eq(1)
+    end
+  end
+
+  describe "#text" do
+    it "returns text" do
+      expect(VSafe::ResponseError.new(response_body).text).to eq("text")
+    end
+  end
+
+  describe "#suggested_message" do
+    it "returns message" do
+      VSafe::ResponseError::SUGGESTED_MESSAGES.keys.each do |code|
+        response_body["ResponseCode"] = code
+        expect(VSafe::ResponseError.new(response_body).suggested_message).to eq(VSafe::ResponseError::SUGGESTED_MESSAGES[code])
+      end
+    end
+  end
+end

data/spec/vsafe/response_spec.rb

@@ -0,0 +1,161 @@
+require "spec_helper"
+require "vsafe/response"
+require "vsafe/response_error"
+require "vsafe/request_error"
+
+RSpec.describe VSafe::Response do
+  let(:error_code) { 1001 }
+  let(:success_body) {
+    {
+      "ResponseCode" => VSafe::Response::SUCCESS_RESPONSE_CODE,
+      "ResponseText" => "Success"
+    }
+  }
+  let(:fail_body) {
+    {
+      "ResponseCode" => error_code.to_s,
+      "ResponseText" => "Login Failed"
+    }
+  }
+
+  context ".new" do
+    context "when request successful" do
+      let(:httparty_response) { double(:response, success?: true, parsed_response: success_body) }
+
+      context "when result is successful" do
+        context "when response code is string" do
+          it "initializes successfully" do
+            response = VSafe::Response.new(httparty_response)
+
+            expect(response.response).to eq(httparty_response)
+            expect(response.to_hash).to eq(success_body)
+            expect(response.error).to eq(nil)
+            expect(response.success?).to eq(true)
+          end
+        end
+
+        context "when response code is integer" do
+          let(:success_body) {
+            {
+              "ResponseCode" => VSafe::Response::SUCCESS_RESPONSE_CODE.to_i,
+              "ResponseText" => "Success"
+            }
+          }
+
+          it "initializes successfully" do
+            response = VSafe::Response.new(httparty_response)
+
+            expect(response.response).to eq(httparty_response)
+            expect(response.to_hash).to eq(success_body)
+            expect(response.error).to eq(nil)
+            expect(response.success?).to eq(true)
+          end
+        end
+      end
+
+      context "when result errored" do
+        let(:httparty_response) { double(:response, success?: true, parsed_response: fail_body) }
+
+        it "initializes successful" do
+          response = VSafe::Response.new(httparty_response)
+          error = response.error
+          expect(response.response).to eq(httparty_response)
+          expect(response.to_hash).to eq(fail_body)
+          expect(error.code).to eq(error_code)
+          expect(error.text).to eq("Login Failed")
+          expect(response.success?).to eq(false)
+        end
+      end
+    end
+
+    context "when request failed" do
+      let(:httparty_response) { double(:response, success?: false, parsed_response: fail_body) }
+
+      it "raises error" do
+        expect {
+          VSafe::Response.new(httparty_response)
+        }.to raise_error(VSafe::RequestError)
+      end
+    end
+  end
+
+  context "#success?" do
+    context "when success" do
+      let(:httparty_response) { double(:response, success?: true, parsed_response: success_body) }
+
+      it "returns true" do
+        response = VSafe::Response.new(httparty_response)
+        expect(response.success?).to eq(true)
+      end
+    end
+
+    context "when fail" do
+      let(:httparty_response) { double(:response, success?: true, parsed_response: fail_body) }
+
+      it "returns false" do
+        response = VSafe::Response.new(httparty_response)
+
+        expect(response.success?).to eq(false)
+      end
+    end
+  end
+
+  context ".define_attribute_mapping" do
+    class ::DummyWrapperClass
+      attr_accessor :value
+
+      def initialize(value)
+        @value = value
+      end
+    end
+
+    class DummyClassNoWrapper < VSafe::Response
+      VSafe::Response.define_attribute_mapping("test1", "Test")
+    end
+
+    class DummyClassWithWrapper < VSafe::Response
+      VSafe::Response.define_attribute_mapping("test2", "Test", DummyWrapperClass)
+    end
+
+    let(:attribute_name) { "test" }
+    let(:response_attribute_name) { "Test" }
+    let(:attribute_value) { "abc" }
+    let(:success_body) {
+      {
+        "ResponseCode" => "0",
+        "ResponseText" => "Success",
+        response_attribute_name => attribute_value
+      }
+    }
+    let(:httparty_response) { double(:response, success?: true, parsed_response: success_body) }
+
+    context "when there is no wrapper" do
+      it "returns attribute value" do
+        response = DummyClassNoWrapper.new(httparty_response)
+
+        expect(response.test1).to eq(attribute_value)
+      end
+    end
+
+    context "when there is wrapper" do
+      it "returns attribute value" do
+        response = DummyClassWithWrapper.new(httparty_response)
+
+        test_result = response.test2
+
+        expect(test_result.is_a?(DummyWrapperClass)).to eq(true)
+        expect(test_result.value).to eq(attribute_value)
+      end
+    end
+  end
+
+  context "#to_hash" do
+    let(:httparty_response) { double(:response, success?: true, parsed_response: success_body) }
+
+    it "returns parsed_response" do
+      response = VSafe::Response.new(httparty_response)
+
+      expect(response.to_hash).to eq(success_body)
+    end
+  end
+end

data/spec/vsafe/responses/charge_account_to_temporary_token_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+require "vsafe/responses/charge_account_to_temporary_token"
+require "vsafe/card_type"
+
+RSpec.describe VSafe::Responses::ChargeAccountToTemporaryToken do
+  let(:body) {
+    {
+      "ResponseCode" => VSafe::Responses::ChargeAccountToTemporaryToken::SUCCESS_RESPONSE_CODE,
+      "ResponseText" => "Success",
+      "ChargeAccountNumberToken" => "abc",
+      "PaymentDeviceLast4" => "1234",
+      "PaymentDeviceTypeCD" => VSafe::CardType::AMERICAN_EXPRESS
+    }
+  }
+  let(:httparty_response) { double(:response, success?: true, parsed_response: body) }
+
+  context "attribute mapping" do
+    it "returns value" do
+      response = VSafe::Responses::ChargeAccountToTemporaryToken.new(httparty_response)
+
+      expect(response.token).to eq("abc")
+      expect(response.last4).to eq("1234")
+      expect(response.card_type).to be_kind_of(VSafe::CardType)
+      expect(response.card_type.code).to eq(VSafe::CardType::AMERICAN_EXPRESS)
+    end
+  end
+end

data/spec/vsafe/responses/charge_authorize_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+require "vsafe/responses/charge_authorize"
+
+RSpec.describe VSafe::Responses::ChargeAuthorize do
+  let(:avs_result_code) { "1" }
+  let(:auth_result_code) { "2" }
+  let(:cvn_result_code) { "3" }
+  let(:charge_permanent_token) { "4" }
+  let(:payment_acquirer_name) { "payment_acquirer_name" }
+  let(:payment_id) { "payment_id" }
+  let(:payment_status) { "5" }
+  let(:success_body) {
+    {
+      "AVSResultCode" => avs_result_code,
+      "AuthResultCode" => auth_result_code,
+      "CVNResultCode" => cvn_result_code,
+      "ChargePermanentToken" => charge_permanent_token,
+      "PaymentAcquirerName" => payment_acquirer_name,
+      "PaymentID" => payment_id,
+      "PaymentStatus" => payment_status
+    }
+  }
+  let(:http_response) { double(:response, success?: true, parsed_response: success_body) }
+  let(:charge_authorize_response) { VSafe::Responses::ChargeAuthorize.new(http_response) }
+
+  context "#avs_result" do
+    it "returns value" do
+      expect(charge_authorize_response.avs_result.code).to eq(avs_result_code.to_i)
+    end
+  end
+
+  context "#auth_result" do
+    it "returns value" do
+      expect(charge_authorize_response.auth_result.code).to eq(auth_result_code.to_i)
+    end
+  end
+
+  context "#charge_permanent_token" do
+    it "returns value" do
+      expect(charge_authorize_response.charge_permanent_token).to eq(charge_permanent_token)
+    end
+  end
+
+  context "#payment_acquirer_name" do
+    it "returns value" do
+      expect(charge_authorize_response.payment_acquirer_name).to eq(payment_acquirer_name)
+    end
+  end
+
+  context "#payment_id" do
+    it "returns value" do
+      expect(charge_authorize_response.payment_id).to eq(payment_id)
+    end
+  end
+
+  context "#payment_status" do
+    it "returns value" do
+      expect(charge_authorize_response.payment_status.code).to eq(payment_status.to_i)
+    end
+  end
+end

data/spec/vsafe/responses/charge_confirm_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "vsafe/responses/charge_confirm"
+
+RSpec.describe VSafe::Responses::ChargeConfirm do
+  let(:payment_status) { "1" }
+  let(:success_body) {
+    {
+      "PaymentStatus" => payment_status
+    }
+  }
+  let(:http_response) { double(:response, success?: true, parsed_response: success_body) }
+
+  context "#payment_status" do
+    it "returns value" do
+      expect(VSafe::Responses::ChargeConfirm.new(http_response).payment_status.code).to eq(payment_status.to_i)
+    end
+  end
+end

data/spec/vsafe/responses/charge_sale_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+require "vsafe/responses/charge_sale"
+
+RSpec.describe VSafe::Responses::ChargeSale do
+  let(:avs_result_code) { "1" }
+  let(:auth_result_code) { "2" }
+  let(:cvn_result_code) { "3" }
+  let(:charge_permanent_token) { "4" }
+  let(:payment_acquirer_name) { "payment_acquirer_name" }
+  let(:payment_id) { "payment_id" }
+  let(:payment_id_pk) { "payment_id_pk" }
+  let(:payment_status) { "5" }
+  let(:success_body) {
+    {
+      "AVSResultCode" => avs_result_code,
+      "AuthResultCode" => auth_result_code,
+      "CVNResultCode" => cvn_result_code,
+      "ChargePermanentToken" => charge_permanent_token,
+      "PaymentAcquirerName" => payment_acquirer_name,
+      "PaymentID" => payment_id,
+      "PaymentID_pk" => payment_id_pk,
+      "PaymentStatus" => payment_status
+    }
+  }
+  let(:http_response) { double(:response, success?: true, parsed_response: success_body) }
+  let(:response) { VSafe::Responses::ChargeSale.new(http_response) }
+  context "#avs_result" do
+    it "returns value" do
+      expect(response.avs_result.code).to eq(avs_result_code.to_i)
+    end
+  end
+
+  context "#auth_result" do
+    it "returns value" do
+      expect(response.auth_result.code).to eq(auth_result_code.to_i)
+    end
+  end
+
+  context "#charge_permanent_token" do
+    it "returns value" do
+      expect(response.charge_permanent_token).to eq(charge_permanent_token)
+    end
+  end
+
+  context "#payment_acquirer_name" do
+    it "returns value" do
+      expect(response.payment_acquirer_name).to eq(payment_acquirer_name)
+    end
+  end
+
+  context "#payment_id" do
+    it "returns value" do
+      expect(response.payment_id).to eq(payment_id)
+    end
+  end
+
+  context "#payment_id_pk" do
+    it "returns value" do
+      expect(response.payment_id_pk).to eq(payment_id_pk)
+    end
+  end
+
+  context "#payment_status" do
+    it "returns value" do
+      expect(response.payment_status.code).to eq(payment_status.to_i)
+    end
+  end
+end

data/spec/vsafe/responses/get_session_tags_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+require "vsafe/responses/get_session_tags"
+
+RSpec.describe VSafe::Responses::GetSessionTags do
+  let(:org_id) { "test_org_id" }
+  let(:web_session_id) { "test_web_session_id" }
+  let(:success_body) {
+    {
+      "OrgID" => org_id,
+      "WebSessionID" => "test_web_session_id"
+    }
+  }
+  let(:http_response) { double(:response, success?: true, parsed_response: success_body) }
+  let(:response) { VSafe::Responses::GetSessionTags.new(http_response) }
+
+  context "#org_id" do
+    it "returns value" do
+      expect(response.org_id).to eq(org_id)
+    end
+  end
+
+  context "#web_session_id" do
+    it "returns value" do
+      expect(response.web_session_id).to eq(web_session_id)
+    end
+  end
+end