paysera 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4db3c9e0b922a48f34110f61da51681ae8820d79
+  data.tar.gz: d5ec01d783c2d30bb1ba344d235b5349bbe9eeb6
+SHA512:
+  metadata.gz: ab25e3b2ef8afdeeb1255cd37f893d3eb60d2cc4937b8a54cf2fe9377993b7179191b24c0651f02c2bcfe9c4acdfb2f7db53f642b96d5afaa74f792e084dd2a2
+  data.tar.gz: b94565c982d25657300bb7454e7cf4e18dce59ef0498965dc9eafe4069720c5437d6f52311a89716604aff20eb38935dd91a336cc4de04b924ebf6e1fcd4890e

data/.gitignore

@@ -0,0 +1,93 @@
+# Created by https://www.gitignore.io
+
+### RubyMine ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm
+
+*.iml
+
+## Directory-based project format:
+.idea/
+# if you remove the above rule, at least ignore the following:
+
+# User-specific stuff:
+# .idea/workspace.xml
+# .idea/tasks.xml
+# .idea/dictionaries
+
+# Sensitive or high-churn files:
+# .idea/dataSources.ids
+# .idea/dataSources.xml
+# .idea/sqlDataSources.xml
+# .idea/dynamic.xml
+# .idea/uiDesigner.xml
+
+# Gradle:
+# .idea/gradle.xml
+# .idea/libraries
+
+# Mongo Explorer plugin:
+# .idea/mongoSettings.xml
+
+## File-based project format:
+*.ipr
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+
+### Linux ###
+*~
+
+# KDE directory preferences
+.directory

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in paysera.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Tomas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,114 @@
+# Paysera
+
+*"Paysera is an advanced, effective, proven and safe electronic money system with an unlimited electronic money licence No. 1 issued by the Bank of Lithuania. It offers a free settlement account which allows for a quick, safe and low-cost (often – free of charge) payment for goods and services.
+ Paysera account is a true electronic wallet, which can not be lost; you will always find the amount of money that you have deposited in your account. In most cases, this type of account is better than bank account, because it is subject to higher security requirements, administrators of Paysera system can not lend or invest money held on the owner’s account.
+ Paysera.com services are constantly expanded and improved by the top-level specialists in accordance with the latest payment innovations."* — [Paysera](https://www.paysera.com/index.html)
+
+This gem provides easy access to Paysera payment API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'paysera'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install paysera
+
+## Usage
+
+You can set default config like so:
+
+```ruby
+Paysera.config do |config|
+  config.projectid = 56571
+  config.sign_password = '36947d6dcbccc03ad591deab138dbb0c'
+end
+```
+
+If you are using *Ruby on Rails* add it to `config/initializers/paysera.rb`. However it do not necessarily has to be rails,
+you can add this into any Ruby app.
+
+### Request
+
+To make a request you only need to execute this:
+
+```ruby
+# Minimum requirements for request_params
+request_params_example = {
+  orderid: 1,
+  accepturl: 'http://0.0.0.0:3000?accept',
+  cancelurl: 'http://0.0.0.0:3000?cancel',
+  callbackurl: 'http://0.0.0.0:3000?callback'
+}
+Paysera::Request.build_request(request_params_example, [sign_password])
+```
+
+It will generate payment link to paysera - `https://mokejimai.lt/pay/?data=...&sign=...`.
+So you can do this if you are using *Rails*:
+
+
+```ruby
+redirect_to Paysera::Request.build_request(...)
+```
+
+You can use all parameters from: https://developers.paysera.com/en/payments/current#request-parameters
+
+If required parameter not found or it is invalid it will raise `Paysera::Error::Request` error with specific error message.
+
+If you specify `projectid` or `sign_password`  it will overwrite initializer.
+
+### Response
+
+```ruby
+# params should include valid data, ss1 and ss2
+response = Paysera::Response.new(params, [projectid], [sign_password])
+```
+
+If `ss1` or `ss2` will fail to validate it will raise `Paysera::Error::Response` error with specific error message.
+
+To check if response is sms/mikro
+
+```ruby
+if response.sms?
+  ...
+end
+```
+
+To check if response is bank/makro:
+
+```ruby
+if response.bank?
+  ...
+end
+```
+
+To get response data:
+
+```ruby
+response.get_data
+```
+
+It will return Hash of data: [SMS specification](https://developers.paysera.com/en/sms-keywords/current#detailed-specification) and [Bank specification(see "Encoded parameters")](https://developers.paysera.com/en/payments/1.6#integration-via-specification)
+
+
+If you specify `projectid` or `sign_password` it will overwrite initializer.
+
+## Contributing
+
+1. Fork it ( https://github.com/TomasAchmedovas/paysera/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+MIT License: see [LICENSE](https://github.com/TomasAchmedovas/paysera/blob/master/LICENSE) file

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/paysera.rb

@@ -0,0 +1,17 @@
+require 'paysera/version'
+require 'paysera/attributes'
+require 'paysera/error'
+require 'paysera/request'
+require 'paysera/response'
+
+module Paysera
+  API_VERSION = '1.6'
+
+  class << self
+    attr_accessor :projectid, :sign_password
+
+    def config
+      yield self
+    end
+  end
+end

data/lib/paysera/attributes.rb

@@ -0,0 +1,155 @@
+class Paysera::Attributes
+    SMS = {
+        :to        => {},
+        :sms       => {},
+        :from      => {},
+        :operator  => {},
+        :amount    => {
+            :maxlen   => 11,
+            :required => false,
+            :regex    => /^\d+$/
+        },
+        :currency  => {
+            :maxlen   => 3,
+            :required => false,
+            :regex    => /^[a-z]{3}$/i
+        },
+        :country   => {
+            :maxlen   => 2,
+            :required => false,
+            :regex    => /^[a-z]{2}$/i
+        },
+        :id        => {},
+        :test      => {
+            :maxlen   => 1,
+            :required => false,
+            :regex    => /^[01]$/
+        },
+        :key       => {},
+        :projectid => {
+            :maxlen   => 11,
+            :required => true,
+            :regex    => /^\d+$/
+        },
+        :version   => {
+            :maxlen   => 9,
+            :required => true,
+            :regex    => /^\d+\.\d+$/
+        }
+    }
+
+    REQUEST = {
+      :projectid         => {
+          :maxlen   => 11,
+          :required => true,
+          :regex    => /^\d+$/
+      },
+      :orderid     => {
+          :maxlen   => 40,
+          :required => true,
+          :regex    => /^\d+$/
+      },
+      :accepturl   => {
+          :maxlen   => 255,
+          :required => true,
+      },
+      :cancelurl   => {
+          :maxlen   => 255,
+          :required => true,
+      },
+      :callbackurl => {
+          :maxlen   => 255,
+          :required => true,
+      },
+      :version           => {
+          :maxlen   => 9,
+          :required => true,
+          :regex    => /^\d+\.\d+$/
+      },
+      :lang              => {
+          :maxlen   => 3,
+          :required => false,
+          :regex    => /^[a-z]{3}$/i
+      },
+      :amount            => {
+          :maxlen   => 11,
+          :required => false,
+          :regex    => /^\d+$/
+      },
+      :currency          => {
+          :maxlen   => 3,
+          :required => false,
+          :regex    => /^[a-z]{3}$/i
+      },
+      :payment           => {
+          :maxlen   => 20,
+          :required => false
+      },
+      :country           => {
+          :maxlen   => 2,
+          :required => false,
+          :regex    => /^[a-z]{2}$/i
+      },
+      :paytext           => {
+          :maxlen   => 255,
+          :required => false,
+      },
+      :p_firstname       => {
+          :maxlen   => 255,
+          :required => false,
+      },
+      :p_lastname        => {
+          :maxlen   => 255,
+          :required => false,
+      },
+      :p_email           => {
+          :maxlen   => 255,
+          :required => false,
+      },
+      :p_street          => {
+          :maxlen   => 255,
+          :required => false,
+      },
+      :p_city            => {
+          :maxlen   => 255,
+          :required => false,
+      },
+      :p_state           => {
+          :maxlen   => 20,
+          :required => false,
+      },
+      :p_zip             => {
+          :maxlen   => 20,
+          :required => false,
+      },
+      :p_countrycode     => {
+          :maxlen   => 2,
+          :required => false,
+          :regex    => /^[a-z]{2}$/i
+      },
+      :only_payments     => {
+          :required => false,
+      },
+      :disallow_payments => {
+          :required => false,
+      },
+      :test              => {
+          :maxlen   => 1,
+          :required => false,
+          :regex    => /^[01]$/
+      },
+      :time_limit        => {
+          :maxlen   => 19,
+          :required => false,
+      },
+      :personcode        => {
+          :maxlen   => 255,
+          :required => false,
+      },
+      :developerid       => {
+          :maxlen   => 11,
+          :required => false,
+          :regex    => /^\d+$/
+      }
+  }
+end

data/lib/paysera/error.rb

@@ -0,0 +1,9 @@
+module Paysera
+  module Error
+    class Response < StandardError
+    end
+
+    class Request < StandardError
+    end
+  end
+end

data/lib/paysera/request.rb

@@ -0,0 +1,76 @@
+require 'base64'
+require 'cgi'
+require 'digest/md5'
+
+module Paysera
+  class Request
+    def self.build_request(paysera_params, sign_password=nil)
+      # Ensure that all key will be symbols
+      paysera_params             = Hash[paysera_params.map { |k, v| [k.to_sym, v] }]
+
+      # Set default values
+      paysera_params[:version]   = Paysera::API_VERSION
+      paysera_params[:projectid] ||= Paysera.projectid
+      sign_password              ||= Paysera.sign_password
+
+      raise send_error("'sign_password' is required but missing") if sign_password.nil?
+
+      valid_request = validate_request(paysera_params)
+      encoded_query  = encode_string make_query(valid_request)
+      signed_request = sign_request(encoded_query, sign_password)
+
+      query = make_query({
+                             :data => encoded_query,
+                             :sign => signed_request
+                         })
+
+
+      "https://www.mokejimai.lt/pay/?#{query}"
+    end
+
+    private
+
+    def self.make_query(data)
+      data.collect do |key, value|
+        "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
+      end.compact.sort! * '&'
+    end
+
+    def self.sign_request(query, password)
+      # Encode string + password with md5
+      Digest::MD5.hexdigest(query + password)
+    end
+
+    def self.encode_string(string)
+      # 1) Encode with base64
+      # 2) Replace / with _ and + with -
+      Base64.encode64(string).gsub("\n", '').gsub('/', '_').gsub('+', '-')
+    end
+
+    def self.validate_request(req)
+      request = {}
+
+      Paysera::Attributes::REQUEST.each do |k, v|
+        raise send_error("'#{k}' is required but missing") if v[:required] and req[k].nil?
+
+        req_value = req[k].to_s
+        regex     = v[:regex].to_s
+        maxlen    = v[:maxlen]
+
+        unless req[k].nil?
+          raise send_error("'#{k}' value '#{req[k]}' is too long, #{v[:maxlen]} characters allowed.") if maxlen and req_value.length > maxlen
+          raise send_error("'#{k}' value '#{req[k]}' invalid.") if '' != regex and !req_value.match(regex)
+
+          # Add only existing params
+          request[k] = req[k]
+        end
+      end
+
+      request
+    end
+
+    def self.send_error(msg)
+      Paysera::Error::Request.new msg
+    end
+  end
+end

data/lib/paysera/response.rb

@@ -0,0 +1,81 @@
+require 'openssl'
+require 'open-uri'
+require 'cgi'
+require 'digest/md5'
+require 'base64'
+
+module Paysera
+  class Response
+    PAYSERA_PUBLIC_KEY = 'https://www.webtopay.com/download/public.key'
+
+    def initialize(query, projectid: nil, sign_password: nil)
+      raise send_error("'data' parameter was not found") if query[:data].nil?
+      raise send_error("'ss1' parameter was not found") if query[:ss1].nil?
+      raise send_error("'ss2' parameter was not found") if query[:ss2].nil?
+
+      projectid ||= Paysera.projectid
+      raise send_error("'projectid' parameter was not found") if projectid.nil?
+
+      sign_password ||= Paysera.sign_password
+      raise send_error("'sign_password' parameter was not found") if sign_password.nil?
+
+      raise send_error("Unable to verify 'ss1'") unless valid_ss1? query[:data], query[:ss1], sign_password
+      raise send_error("Unable to verify 'ss2'") unless valid_ss2? query[:data], query[:ss2]
+
+      @data = convert_to_hash safely_decode_string(query[:data])
+
+      raise send_error("'projectid' mismatch") if @data[:projectid].to_i != projectid
+    end
+
+    def sms?
+      # Basically if response data have sms param then it is sms payment
+      @data.key? :sms
+    end
+
+    def bank?
+      # Same here, if response have paytext param, then it is bank payment
+      @data.key? :paytext
+    end
+
+    def get_data
+      @data
+    end
+
+    private
+
+    def convert_to_hash(query)
+      Hash[query.split('&').collect do |s|
+             a = s.split('=')
+             [unescape_string(a[0]).to_sym, unescape_string(a[1])]
+           end]
+    end
+
+    def valid_ss1?(data, ss1, sign_password)
+      Digest::MD5.hexdigest(CGI.unescape(data) + sign_password) == ss1
+    end
+
+    def valid_ss2?(data, ss2)
+      public_key = get_public_key
+      ss2        = unescape_string safely_decode_string(unescape_string(ss2))
+      data       = unescape_string data
+
+      public_key.verify(OpenSSL::Digest::SHA1.new, ss2, data)
+    end
+
+    def get_public_key
+      OpenSSL::X509::Certificate.new(open(PAYSERA_PUBLIC_KEY).read).public_key
+    end
+
+    def safely_decode_string(string)
+      Base64.decode64 string.gsub('-', '+').gsub('_', '/').gsub("\n", '')
+    end
+
+    def unescape_string(string)
+      CGI.unescape string.to_s
+    end
+
+    def send_error(msg)
+      Paysera::Error::Response.new msg
+    end
+  end
+end

data/lib/paysera/version.rb

@@ -0,0 +1,3 @@
+module Paysera
+  VERSION = '0.0.1'
+end

data/paysera.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'paysera/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'paysera'
+  spec.version       = Paysera::VERSION
+  spec.authors       = ['Tomas Achmedovas']
+  spec.email         = ['achmedovas.tomas@gmail.com']
+  spec.summary       = %q{Paysera.com payment API}
+  spec.description   = %q{Paysera.com payment API}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+end

data/spec/request_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'cgi'
+require 'digest/md5'
+
+describe Paysera::Request do
+  let(:valid_request) do
+    {
+        projectid:   56571,
+        orderid:     1,
+        accepturl:   '0.0.0.0:3000/get_request?accept',
+        cancelurl:   '0.0.0.0:3000/get_request?cancel',
+        callbackurl: '0.0.0.0:3000/get_request?callback',
+
+    }
+  end
+  let(:sign_password) { '36947d6dcbccc03ad591deab138dbb0c' }
+
+  subject { Paysera::Request.build_request(valid_request, sign_password) }
+
+  describe '#build_request' do
+    context 'when no projectid given' do
+      let (:invalid_request) { valid_request.delete(:projectid); valid_request }
+      it { expect { Paysera::Request.build_request(invalid_request, sign_password) }.to raise_error /projectid.+missing/ }
+    end
+
+    context 'when no orderid given' do
+      let (:invalid_request) { valid_request.delete(:orderid); valid_request }
+      it { expect { Paysera::Request.build_request(invalid_request, sign_password) }.to raise_error /orderid.+missing/ }
+    end
+
+    context 'when no accepturl given' do
+      let (:invalid_request) { valid_request.delete(:accepturl); valid_request }
+      it { expect { Paysera::Request.build_request(invalid_request, sign_password) }.to raise_error /accepturl.+missing/ }
+    end
+
+    context 'when no cancelurl given' do
+      let (:invalid_request) { valid_request.delete(:cancelurl); valid_request }
+      it { expect { Paysera::Request.build_request(invalid_request, sign_password) }.to raise_error /cancelurl.+missing/ }
+    end
+
+    context 'when no callbackurl given' do
+      let (:invalid_request) { valid_request.delete(:callbackurl); valid_request }
+      it { expect { Paysera::Request.build_request(invalid_request, sign_password) }.to raise_error /callbackurl.+missing/ }
+    end
+
+    context 'when no sign_password given' do
+      it { expect { Paysera::Request.build_request(valid_request, nil) }.to raise_error /sign_password.+missing/ }
+    end
+
+    context 'when valid' do
+      it { expect(subject).to match(/^https:\/\/(www\.)*(mokejimai|paysera)\.(lt|com)\/pay\/*\?(data|sign)=.+&(data|sign)=.+$/i) }
+    end
+
+    context 'when generated url params are valid' do
+      let(:request) { Hash[subject.split('?')[1].split('&').map { |a| k=a.split('='); [k[0].to_sym, CGI.unescape(k[1]).gsub('+', '-').gsub('/', '_')] }] }
+
+      it { expect(Digest::MD5.hexdigest(request[:data] + sign_password)).to eq(request[:sign]) }
+    end
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Paysera::Response do
+
+  # TODO: add sms response
+  let(:response_data) do
+    {
+        :data => 'b3JkZXJpZD0xMjM0JnByb2plY3RpZD01NjU3MSZ0ZXN0PTEmdmVyc2lvbj0xLjYmdHlwZT1URVNUJmxhbmc9JnBheW1lbnQ9aGFuemEmY3VycmVuY3k9TFRMJmFtb3VudD0xMDAwMDAmcGF5dGV4dD1PcmRlcitObyUzQSsxMjM0K2F0K2h0dHAlM0ElMkYlMkZwYXlzZXJhLndwci5sdCtwcm9qZWN0LislMjhTZWxsZXIlM0ErVG9tYXMrQWNobWVkb3ZhcyUyOSZwX2VtYWlsPXRyeWtpejExJTQwZ21haWwuY29tJmNvdW50cnk9TFQmbV9wYXlfcmVzdG9yZWQ9MHg0Jl9jbGllbnRfbGFuZ3VhZ2U9ZW5nJnJlY2VpdmVyaWQ9MTg2NTA2JnN0YXR1cz0xJnBheWFtb3VudD0xMDAwMDAmcGF5Y3VycmVuY3k9TFRMJnJlcXVlc3RpZD02OTk0MzY5NyZuYW1lPSZzdXJlbmFtZT0%3D',
+        :ss1  => '0a58f2b1fe7972e616a01150427f7912',
+        :ss2  => '02pTV2VtdxJlMIdrKakCHpIxgiG--1iUwZkxikwAvqPEiiEj_ekmMYsnYDu3B8RlrmDBWrsSIRLIaPwOGLbInQc9vduK3lsjm9PQ9RImNXEHcc5Pyk-6cQ93U833bQ73r5NxvwfxE8s3KhBUxwHDLTSPCMnF7yEhskLx63I0SW8%3D'
+    }
+  end
+  let(:projectid) { 56571 }
+  let(:sign_password) { '36947d6dcbccc03ad591deab138dbb0c' }
+
+  subject(:bank_response) { Paysera::Response.new response_data, projectid: projectid, sign_password: sign_password }
+  subject(:sms_response) { Paysera::Response.new response_data, projectid: projectid, sign_password: sign_password }
+
+  describe '#initialize' do
+    def new_response(data: nil, ss1: nil, ss2: nil, p_id: nil, sign: nil)
+      Paysera::Response.new({ data: data, ss1: ss1, ss2: ss2 }, projectid: p_id, sign_password: sign)
+    end
+
+    context 'when no data param' do
+      it { expect { new_response(ss1: 't', ss2: 't', p_id: 1, sign: 't') }.to raise_exception /data.+not\sfound/i }
+    end
+
+    context 'when no ss1 param' do
+      it { expect { new_response(data: 't', ss2: 't', p_id: 1, sign: 't') }.to raise_exception /ss1.+not\sfound/i }
+    end
+
+    context 'when no ss2 param' do
+      it { expect { new_response(data: 't', ss1: 't', p_id: 1, sign: 't') }.to raise_exception /ss2.+not\sfound/i }
+    end
+
+    context 'when no projectid param' do
+      it { expect { new_response(data: 't', ss1: 't', ss2: 't', sign: 't') }.to raise_exception /projectid.+not\sfound/i }
+    end
+
+    context 'when no sign_password param' do
+      it { expect { new_response(data: 't', ss1: 't', ss2: 't', p_id: 1) }.to raise_exception /sign_password.+not\sfound/i }
+    end
+
+    context 'when invalid ss1' do
+      it { expect { new_response(data: response_data[:data],
+                                 ss1:  't',
+                                 ss2:  response_data[:ss2],
+                                 p_id: projectid,
+                                 sign: sign_password) }.to raise_exception /verify.+ss1/i }
+    end
+
+    context 'when invalid ss2' do
+      it { expect { new_response(data: response_data[:data],
+                                 ss1:  response_data[:ss1],
+                                 ss2:  't',
+                                 p_id: projectid,
+                                 sign: sign_password) }.to raise_exception /verify.+ss2/i }
+    end
+
+    context 'when projectid mismatch' do
+      it { expect { new_response(data: response_data[:data],
+                                 ss1:  response_data[:ss1],
+                                 ss2:  response_data[:ss2],
+                                 p_id: 1,
+                                 sign: sign_password) }.to raise_exception /projectid.+mismatch/i }
+    end
+  end
+
+  describe '#bank?' do
+    context 'when sms response' do
+      it { expect(sms_response.bank?).to be false }
+    end
+
+    context 'when bank response' do
+      it { expect(bank_response.bank?).to be true }
+    end
+  end
+
+  describe '#sms?' do
+    context 'when bank response' do
+      it { expect(bank_response.sms?).to be false }
+    end
+
+    context 'when bank response' do
+      it { expect(sms_response.sms?).to be true }
+    end
+  end
+
+  describe '#get_data' do
+    it { expect(bank_response.get_data).to be_kind_of(Hash) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'paysera'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: paysera
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tomas Achmedovas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Paysera.com payment API
+email:
+- achmedovas.tomas@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/paysera.rb
+- lib/paysera/attributes.rb
+- lib/paysera/error.rb
+- lib/paysera/request.rb
+- lib/paysera/response.rb
+- lib/paysera/version.rb
+- paysera.gemspec
+- spec/request_spec.rb
+- spec/response_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Paysera.com payment API
+test_files:
+- spec/request_spec.rb
+- spec/response_spec.rb
+- spec/spec_helper.rb