straight-server 0.2.3 → 1.0.0

data/lib/straight-server/thread.rb

@@ -1,9 +1,24 @@
 module StraightServer
-
   class Thread
-    def self.new(&block)
-      ::Thread.new(&block)
+
+    def self.new(label: nil, &block)
+      thread         = ::Thread.new(&block)
+      thread[:label] = label
+      thread
     end
-  end
 
+    INTERRUPTION_FLAG = lambda { |label| "#{Config[:'redis.prefix']}:interrupt_thread:#{label}" }
+
+    def self.interrupt(label:)
+      redis = StraightServer.redis_connection
+      redis.set INTERRUPTION_FLAG[label], Time.now.to_i
+    end
+
+    def self.interrupted?(thread:)
+      redis  = StraightServer.redis_connection
+      result = redis.get(key = INTERRUPTION_FLAG[thread[:label]])
+      redis.del key if result
+      !!result
+    end
+  end
 end

data/lib/straight-server/throttler.rb

@@ -2,20 +2,16 @@ module StraightServer
   class Throttler
 
     def initialize(gateway_id)
-      @id    = "gateway_#{gateway_id}"
-      @redis = Config.redis && Config.redis[:connection]
-      @limit = @period = @ip_ban_duration = 0
-      if Config.throttle
-        @limit           = Config.throttle[:requests_limit].to_i
-        @period          = Config.throttle[:period].to_i # in seconds
-        @ip_ban_duration = Config.throttle[:ip_ban_duration].to_i # in seconds
-      end
+      @id              = "gateway_#{gateway_id}"
+      @redis           = StraightServer.redis_connection
+      @limit           = Config[:'throttle.requests_limit'].to_i
+      @period          = Config[:'throttle.period'].to_i # in seconds
+      @ip_ban_duration = Config[:'throttle.ip_ban_duration'].to_i # in seconds
     end
 
     # @param [String] ip address
     # @return [Boolean|Nil] true if request should be rejected,
     #                       false if request should be served,
-    #                       nil if redis is not available
     def deny?(ip)
       banned?(ip) || throttled?(ip)
     end
@@ -24,7 +20,6 @@ module StraightServer
 
     def throttled?(ip)
       return false if @limit <= 0 || @period <= 0
-      return unless @redis
       key   = throttled_key(ip)
       value = @redis.incr(key)
       @redis.expire key, @period * 2
@@ -38,7 +33,6 @@ module StraightServer
 
     def banned?(ip)
       return false if @ip_ban_duration <= 0
-      return unless @redis
       value = @redis.get(banned_key(ip)).to_i
       if value > 0
         Time.now.to_i <= value + @ip_ban_duration
@@ -53,11 +47,11 @@ module StraightServer
     end
 
     def throttled_key(ip)
-      "#{Config.redis[:prefix]}:Throttle:#{@id}:#{@period}_#{@limit}:#{Time.now.to_i / @period}:#{ip}"
+      "#{Config[:'redis.prefix']}:Throttle:#{@id}:#{@period}_#{@limit}:#{Time.now.to_i / @period}:#{ip}"
     end
 
     def banned_key(ip)
-      "#{Config.redis[:prefix]}:BannedIP:#{ip}"
+      "#{Config[:'redis.prefix']}:BannedIP:#{ip}"
     end
   end
 end

data/lib/tasks/db.rake

@@ -21,7 +21,7 @@ namespace :db do
   desc "Rollbacks database migrations"
   task :rollback, [:step] => :environment do |t, args|
     target = args[:step] && (step = args[:step].to_i) > 0 ?
-      current_migration_version - step : 0
+      current_migration_version - step : current_migration_version - 1
 
     Sequel::Migrator.run(StraightServer.db_connection, MIGRATIONS_ROOT, target: target)
     dump_schema

data/spec/.straight/config.yml

@@ -7,9 +7,9 @@ expiration_overtime: 0
 reuse_address_orders_threshold: 5
 
 gateways:
-
   default:
     pubkey: 'xpub6Arp6y5VVQzq3LWTHz7gGsGKAdM697RwpWgauxmyCybncqoAYim6P63AasNKSy3VUAYXFj7tN2FZ9CM9W7yTfmerdtAPU4amuSNjEKyDeo6'
+    test_pubkey: 'tpubDCzMzH5R7dvZAN7jNyZRUXxuo8XdRmMd7gmzvHs9LYG4w2EBvEjQ1Drm8ZXv4uwxrtUh3MqCZQJaq56oPMghsbtFnoLi9JBfG7vRLXLH21r'
     confirmations_required: 0
     order_class: "StraightServer::Order"
     secret: 'secret'
@@ -22,6 +22,7 @@ gateways:
       - Coinbase
       - Bitstamp
     active: true
+    test_mode: true
   second_gateway:
     pubkey: 'xpub6AH1Ymkkrwk3TaMrVrXBCpcGajKc9a1dAJBTKr1i4GwYLgLk7WDvPtN1o1cAqS5DZ9CYzn3gZtT7BHEP4Qpsz24UELTncPY1Zsscsm3ajmX'
     confirmations_required: 0
@@ -38,9 +39,13 @@ gateways:
     active: true
 
 blockchain_adapters:
+  - Insight
   - BlockchainInfo
   - Mycelium
 
+insight_url: "https://insight.mycelium.com/api"
+insight_test_url: "https://test-insight.bitpay.com"
+  
 db:
   adapter: sqlite
   name: straight.db
@@ -48,5 +53,5 @@ db:
 redis:
   host: localhost
   port: 6379
-  db:   null
-  password: null
+  # db:   null
+  # password: null

data/spec/.straight/default_test_last_keychain_id

@@ -0,0 +1 @@
+0

data/spec/factories.rb

@@ -1,11 +1,12 @@
 FactoryGirl.define do
-  
+
   factory :order, class: StraightServer::Order do
     sequence(:id)          { |i| i }
     sequence(:keychain_id) { |i| i }
     sequence(:address)     { |i| "address_#{i}" }
     amount 10
     gateway_id 1
+    to_create { |order| order.save }
   end
 
 end

data/spec/lib/gateway_spec.rb

@@ -6,34 +6,16 @@ RSpec.describe StraightServer::Gateway do
     @gateway = StraightServer::GatewayOnConfig.find_by_id(1)
     @order_mock = double("order mock")
     allow(@order_mock).to receive(:old_status)
+    allow(@order_mock).to receive(:description=)
+    allow(@order_mock).to receive(:set_amount_paid)
     allow(@order_mock).to receive(:reused).and_return(0)
-    [:id, :gateway=, :save, :to_h, :id=].each { |m| allow(@order_mock).to receive(m) }
-    @order_for_keychain_id_args = { amount: 1, keychain_id: 1, currency: nil, btc_denomination: nil }
-  end
-
-  it "checks for signature when creating a new order" do
-    @gateway.last_keychain_id = 0
-    expect( -> { @gateway.create_order(amount: 1, signature: 'invalid', id: 1) }).to raise_exception(StraightServer::GatewayModule::InvalidSignature)
-    expect(@gateway).to receive(:order_for_keychain_id).with(@order_for_keychain_id_args).once.and_return(@order_mock)
-    @gateway.create_order(amount: 1, signature: hmac_sha256(1, 'secret'), keychain_id: 1)
-  end
-
-  it "checks md5 signature only if that setting is set ON for a particular gateway" do
-    gateway1 = StraightServer::GatewayOnConfig.find_by_id(1)
-    gateway2 = StraightServer::GatewayOnConfig.find_by_id(2)
-    expect(gateway2).to receive(:order_for_keychain_id).with(@order_for_keychain_id_args).once.and_return(@order_mock)
-    expect( -> { gateway1.create_order(amount: 1, signature: 'invalid') }).to raise_exception
-    expect( -> { gateway2.create_order(amount: 1, signature: 'invalid') }).not_to raise_exception()
-  end
-
-  it "doesn't allow nil or empty order id if signature checks are enabled" do
-    expect( -> { @gateway.create_order(amount: 1, signature: hmac_sha256(nil, 'secret'), id: nil) }).to raise_exception(StraightServer::GatewayModule::InvalidOrderId)
-    expect( -> { @gateway.create_order(amount: 1, signature: hmac_sha256('', 'secret'), id: '') }).to raise_exception(StraightServer::GatewayModule::InvalidOrderId)
+    allow(@order_mock).to receive(:test_mode)
+    [:id, :gateway=, :save, :to_h, :id=, :test_mode=, :test_mode].each { |m| allow(@order_mock).to receive(m) }
+    @new_order_args = { amount: 1, keychain_id: 1, currency: nil, btc_denomination: nil }
   end
 
   it "sets order amount in satoshis calculated from another currency" do
     @gateway = StraightServer::GatewayOnConfig.find_by_id(2)
-    allow(@gateway).to receive(:address_for_keychain_id).and_return('address')
     allow(@gateway.exchange_rate_adapters.first).to receive(:rate_for).and_return(450.5412)
     expect(@gateway.create_order(amount: 2252.706, currency: 'USD').amount).to eq(500000000)
   end
@@ -45,21 +27,38 @@ RSpec.describe StraightServer::Gateway do
   end
 
   it "loads blockchain adapters according to the config file" do
-    expect(@gateway.blockchain_adapters.map(&:class)).to eq([Straight::Blockchain::BlockchainInfoAdapter, Straight::Blockchain::MyceliumAdapter])
+    gateway = StraightServer::GatewayOnConfig.find_by_id(2)
+    expect(gateway.blockchain_adapters.map(&:class)).to eq([Straight::Blockchain::InsightAdapter,
+                                                            Straight::Blockchain::BlockchainInfoAdapter,
+                                                            Straight::Blockchain::MyceliumAdapter])
+  end
+
+  it "loads Insight adapter with given host url" do
+    gateway = StraightServer::GatewayOnConfig.find_by_id(2)
+    expect(gateway.blockchain_adapters.first.class).to eq(Straight::Blockchain::InsightAdapter)
   end
 
   it "updates last_keychain_id to the new value provided in keychain_id if it's larger than the last_keychain_id" do
-    @gateway.create_order(amount: 2252.706, currency: 'USD', signature: hmac_sha256('100', 'secret'), keychain_id: 100)
-    expect(@gateway.last_keychain_id).to eq(100) 
-    @gateway.create_order(amount: 2252.706, currency: 'USD', signature: hmac_sha256('150', 'secret'), keychain_id: 150)
-    expect(@gateway.last_keychain_id).to eq(150) 
-    @gateway.create_order(amount: 2252.706, currency: 'USD', signature: hmac_sha256('50', 'secret'), keychain_id: 50)
+    gateway = StraightServer::GatewayOnConfig.find_by_id(2)
+    gateway.create_order(amount: 2252.706, currency: 'BTC', keychain_id: 100)
+    expect(gateway.last_keychain_id).to eq(100)
+    gateway.create_order(amount: 2252.706, currency: 'BTC', keychain_id: 150)
+    expect(gateway.last_keychain_id).to eq(150)
+    gateway.create_order(amount: 2252.706, currency: 'BTC', keychain_id: 50)
+  end
+
+  it "only warns about an invalid Bitcoin address, but doesn't fail", one: true do
+    expect(StraightServer.logger).to receive(:warn) 
+    allow_any_instance_of(Straight::Blockchain::MyceliumAdapter).to receive(:api_request).and_return(nil)
+    allow_any_instance_of(Straight::Blockchain::InsightAdapter).to receive(:api_request).and_return(nil)
+    # mainnet Bitcoin address, while we're on testnet
+    expect(@gateway.fetch_transactions_for('12X3JTpcGPS1GXmuJn9gT3gspP6YFsFT6W')).to eq([])
   end
 
   context "reusing addresses" do
 
     # Config.reuse_address_orders_threshold for the test env is 5
-    
+
     before(:each) do
       @gateway = StraightServer::GatewayOnConfig.find_by_id(2)
       allow(@gateway).to receive(:order_status_changed).with(anything).and_return([])
@@ -79,7 +78,7 @@ RSpec.describe StraightServer::Gateway do
     it "picks an expired order which address is going to be reused" do
       expect(@gateway.find_reusable_order).to eq(@expired_orders_1.last)
     end
-     
+
     it "picks an expired order which address is going to be reused only when this address received no transactions" do
       allow(@gateway).to receive(:fetch_transactions_for).with(@expired_orders_1.last.address).and_return(['transaction'])
       expect(@gateway.find_reusable_order).to eq(nil)
@@ -87,30 +86,30 @@ RSpec.describe StraightServer::Gateway do
 
     it "creates a new order with a reused address" do
       reused_order = @expired_orders_1.last
-      order        = @gateway.create_order(amount: 2252.706, currency: 'USD')
+      order        = @gateway.create_order(amount: 2252.706, currency: 'BTC')
       expect(order.keychain_id).to eq(reused_order.keychain_id)
-      expect(order.address).to     eq(@gateway.address_for_keychain_id(reused_order.keychain_id)) 
+      expect(order.address).to     eq(@gateway.address_provider.new_address(keychain_id: reused_order.keychain_id))
       expect(order.reused).to      eq(1)
     end
 
     it "doesn't increment last_keychain_id if order is reused" do
       last_keychain_id = @gateway.last_keychain_id
-      order = @gateway.create_order(amount: 2252.706, currency: 'USD')
-      expect(@gateway.last_keychain_id).to eq(last_keychain_id) 
+      order = @gateway.create_order(amount: 2252.706, currency: 'BTC')
+      expect(@gateway.last_keychain_id).to eq(last_keychain_id)
 
       order.status = StraightServer::Order::STATUSES[:paid]
       order.save
-      order_2 = @gateway.create_order(amount: 2252.706, currency: 'USD')
-      expect(@gateway.last_keychain_id).to eq(last_keychain_id+1) 
+      order_2 = @gateway.create_order(amount: 2252.706, currency: 'BTC')
+      expect(@gateway.last_keychain_id).to eq(last_keychain_id+1)
     end
 
     it "after the reused order was paid, gives next order a new keychain_id" do
-      order = @gateway.create_order(amount: 2252.706, currency: 'USD')
+      order = @gateway.create_order(amount: 2252.706, currency: 'BTC')
       order.status = StraightServer::Order::STATUSES[:expired]
       order.save
-      expect(order.keychain_id).to eq(@expired_orders_1.last.keychain_id) 
+      expect(order.keychain_id).to eq(@expired_orders_1.last.keychain_id)
 
-      order = @gateway.create_order(amount: 2252.706, currency: 'USD')
+      order = @gateway.create_order(amount: 2252.706, currency: 'BTC')
       order.status = StraightServer::Order::STATUSES[:paid]
       order.save
       expect(@gateway.send(:find_expired_orders_row).map(&:id)).to be_empty
@@ -121,53 +120,47 @@ RSpec.describe StraightServer::Gateway do
   context "callback url" do
 
     before(:each) do
-      @gateway = StraightServer::GatewayOnConfig.find_by_id(2) # Gateway 2 doesn't require signatures
-      @response_mock = double("http response mock")
-      expect(@response_mock).to receive(:body).once.and_return('body')
-      @order = create(:order)
+      @gateway = StraightServer::GatewayOnConfig.find_by_id(2)
+      @order = build(:order, gateway: @gateway, address: 'address_1', keychain_id: 1, id: 1)
       allow(@order).to receive(:status).and_return(1)
       allow(@order).to receive(:tid).and_return('tid1')
     end
 
-    it "sends a request to the callback_url" do
-      expect(@response_mock).to receive(:code).twice.and_return("200")
-      expect(Net::HTTP).to receive(:get_response).and_return(@response_mock)
+    it "sends a request to the callback_url and saves response" do
+      stub_request(:get, 'http://localhost:3001/payment-callback?address=address_1&amount=10&amount_in_btc=0.0000001&amount_paid_in_btc=0.0&keychain_id=1&last_keychain_id=0&order_id=1&status=1&tid=tid1').
+        with(headers: {'X-Signature' => 'u7DrzCaVirO1gehac9Fvkh4bMfR5lTn8FI8lHOvZzuEvHEGJrdFHTm6k6Q+fpTuszXG0ftKBc4a1xclpZjpTHA=='}).
+        to_return(status: 200, body: 'okay')
+      expect(@gateway).to receive(:sleep).exactly(0).times
       @gateway.order_status_changed(@order)
+      expect(@order.callback_response).to eq(code: '200', body: 'okay')
     end
 
     it "keeps sending request according to the callback schedule if there's an error" do
-      expect(@response_mock).to receive(:code).twice.and_return("404")
+      stub_request(:get, 'http://localhost:3001/payment-callback?address=address_1&amount=10&amount_in_btc=0.0000001&amount_paid_in_btc=0.0&keychain_id=1&last_keychain_id=0&order_id=1&status=1&tid=tid1').
+        with(headers: {'X-Signature' => 'u7DrzCaVirO1gehac9Fvkh4bMfR5lTn8FI8lHOvZzuEvHEGJrdFHTm6k6Q+fpTuszXG0ftKBc4a1xclpZjpTHA=='}).
+        to_return(status: 404, body: '')
       expect(@gateway).to receive(:sleep).exactly(10).times
-      expect(Net::HTTP).to receive(:get_response).exactly(11).times.and_return(@response_mock)
-      expect(URI).to receive(:parse).with('http://localhost:3001/payment-callback?' + @order.to_http_params).exactly(11).times
-      @gateway.order_status_changed(@order)
-    end
-
-    it "signs the callback if gateway has a secret" do
-      @gateway = StraightServer::GatewayOnConfig.find_by_id(1) # Gateway 1 requires signatures
-      expect(@response_mock).to receive(:code).twice.and_return("200")
-      expect(URI).to receive(:parse).with('http://localhost:3000/payment-callback?' + @order.to_http_params + "&signature=#{hmac_sha256(@order.id, 'secret')}")
-      expect(Net::HTTP).to receive(:get_response).and_return(@response_mock)
       @gateway.order_status_changed(@order)
     end
 
     it "receives random data in :data params and sends it back in a callback request" do
-      @order.data = 'some random data'
-      expect(@gateway).to receive(:order_for_keychain_id).with(@order_for_keychain_id_args).once.and_return(@order)
-      @gateway.create_order(amount: 1, callback_data: 'some random data')
-      expect(@response_mock).to receive(:code).twice.and_return("200")
-      expect(Net::HTTP).to receive(:get_response).and_return(@response_mock)
-      expect(URI).to receive(:parse).with('http://localhost:3001/payment-callback?' + @order.to_http_params + "&callback_data=#{@order.data}")
+      uri = "/payment-callback?order_id=1&amount=10&amount_in_btc=0.0000001&amount_paid_in_btc=0.0&status=1&address=address_1&tid=tid1&keychain_id=1&last_keychain_id=1&callback_data=so%3Fme+ran%26dom+data"
+      signature = 'Q6X8n1W4/oTZ9aULeAxZ9E/yPWvs8yiawvttupVor+naITtCqe5bUrRDuDYJYcSPZ7Z3l0T8CyqhYfgX6R+qdw=='
+      expect(StraightServer::SignatureValidator.signature(nonce: nil, body: nil, method: 'GET', request_uri: uri, secret: @gateway.secret)).to eq signature
+      stub_request(:get, "http://localhost:3001#{uri}").with(headers: {'X-Signature' => signature}).to_return(status: 200, body: '')
+      expect(@gateway).to receive(:new_order).with(@new_order_args).once.and_return(@order)
+      @gateway.create_order(amount: 1, callback_data: 'so?me ran&dom data')
       @gateway.order_status_changed(@order)
     end
 
-    it "saves callback url response in the order's record in DB" do
-      allow(@response_mock).to receive(:code).and_return("200")
-      allow(Net::HTTP).to receive(:get_response).and_return(@response_mock)
+    it "uses callback_url from order when making callback" do
+      uri = '/?with=params&order_id=1&amount=10&amount_in_btc=0.0000001&amount_paid_in_btc=0.0&status=1&address=address_1&tid=tid1&keychain_id=1&last_keychain_id=0'
+      signature = 'MtRdAHH6lxsdD8LaoKsKyw/RDzfsh/OimmsciXhaAGyFFcm5/7bBKPygKn+41DHBK65gNcO/abgxOBR1Se2FdA=='
+      expect(StraightServer::SignatureValidator.signature(nonce: nil, body: nil, method: 'GET', request_uri: uri, secret: @gateway.secret)).to eq signature
+      stub_request(:get, "http://new_url#{uri}").with(headers: {'X-Signature' => signature}).to_return(status: 200, body: '')
+      @order.callback_url = 'http://new_url?with=params'
       @gateway.order_status_changed(@order)
-      expect(@order.callback_response).to eq({code: "200", body: "body"}) 
     end
-
   end
 
   describe "order counters" do
@@ -180,8 +173,8 @@ RSpec.describe StraightServer::Gateway do
 
     it "raises exception when trying to access counters but the feature is disabled" do
       allow(StraightServer::Config).to receive(:count_orders).and_return(false)
-      expect( -> { @gateway.order_counters(reload: true) }).to raise_exception(StraightServer::Gateway::OrderCountersDisabled) 
-      expect( -> { @gateway.increment_order_counter!(:new) }).to raise_exception(StraightServer::Gateway::OrderCountersDisabled) 
+      expect( -> { @gateway.order_counters(reload: true) }).to raise_exception(StraightServer::Gateway::OrderCountersDisabled)
+      expect( -> { @gateway.increment_order_counter!(:new) }).to raise_exception(StraightServer::Gateway::OrderCountersDisabled)
     end
 
     it "updates gateway's order counters when an associated order status changes" do
@@ -189,19 +182,19 @@ RSpec.describe StraightServer::Gateway do
       allow(@gateway).to receive(:send_callback_http_request)
       allow(@gateway).to receive(:send_order_to_websocket_client)
 
-      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 0, paid: 0, underpaid: 0, overpaid: 0, expired: 0 })
+      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 0, paid: 0, underpaid: 0, overpaid: 0, expired: 0, canceled: 0 })
       order = create(:order, gateway_id: @gateway.id)
-      expect(@gateway.order_counters(reload: true)).to eq({ new: 1, unconfirmed: 0, paid: 0, underpaid: 0, overpaid: 0, expired: 0 })
+      expect(@gateway.order_counters(reload: true)).to eq({ new: 1, unconfirmed: 0, paid: 0, underpaid: 0, overpaid: 0, expired: 0, canceled: 0 })
       order.status = 2
-      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 0, paid: 1, underpaid: 0, overpaid: 0, expired: 0 })
+      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 0, paid: 1, underpaid: 0, overpaid: 0, expired: 0, canceled: 0 })
 
-      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 0, paid: 1, underpaid: 0, overpaid: 0, expired: 0 })
+      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 0, paid: 1, underpaid: 0, overpaid: 0, expired: 0, canceled: 0 })
       order = create(:order, gateway_id: @gateway.id)
-      expect(@gateway.order_counters(reload: true)).to eq({ new: 1, unconfirmed: 0, paid: 1, underpaid: 0, overpaid: 0, expired: 0 })
+      expect(@gateway.order_counters(reload: true)).to eq({ new: 1, unconfirmed: 0, paid: 1, underpaid: 0, overpaid: 0, expired: 0, canceled: 0 })
       order.status = 1
-      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 1, paid: 1, underpaid: 0, overpaid: 0, expired: 0 })
+      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 1, paid: 1, underpaid: 0, overpaid: 0, expired: 0, canceled: 0 })
       order.status = 5
-      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 0, paid: 1, underpaid: 0, overpaid: 0, expired: 1 })
+      expect(@gateway.order_counters(reload: true)).to eq({ new: 0, unconfirmed: 0, paid: 1, underpaid: 0, overpaid: 0, expired: 1, canceled: 0 })
     end
 
     it "doesn't increment orders on status update unless the option is turned on (but no exception raised)" do
@@ -210,7 +203,7 @@ RSpec.describe StraightServer::Gateway do
       allow(@gateway).to receive(:send_callback_http_request)
       allow(@gateway).to receive(:send_order_to_websocket_client)
       order = create(:order, gateway_id: @gateway.id)
-      expect(StraightServer::Config.redis[:connection].get("#{StraightServer::Config.redis[:prefix]}:gateway_#{@gateway.id}:new_orders_counter")).to be_nil
+      expect(StraightServer.redis_connection.get("#{StraightServer::Config.redis[:prefix]}:gateway_#{@gateway.id}:new_orders_counter")).to be_nil
     end
 
   end
@@ -223,33 +216,79 @@ RSpec.describe StraightServer::Gateway do
       expect(gateway1).to be_kind_of(StraightServer::GatewayOnConfig)
       expect(gateway2).to be_kind_of(StraightServer::GatewayOnConfig)
 
-      expect(gateway1.pubkey).to eq('xpub6Arp6y5VVQzq3LWTHz7gGsGKAdM697RwpWgauxmyCybncqoAYim6P63AasNKSy3VUAYXFj7tN2FZ9CM9W7yTfmerdtAPU4amuSNjEKyDeo6') 
-      expect(gateway1.confirmations_required).to eq(0) 
-      expect(gateway1.order_class).to eq("StraightServer::Order") 
-      expect(gateway1.name).to eq("default") 
+      expect(gateway1.pubkey).to eq('xpub6Arp6y5VVQzq3LWTHz7gGsGKAdM697RwpWgauxmyCybncqoAYim6P63AasNKSy3VUAYXFj7tN2FZ9CM9W7yTfmerdtAPU4amuSNjEKyDeo6')
+      expect(gateway1.confirmations_required).to eq(0)
+      expect(gateway1.order_class).to eq("StraightServer::Order")
+      expect(gateway1.name).to eq("default")
 
-      expect(gateway2.pubkey).to eq('xpub6AH1Ymkkrwk3TaMrVrXBCpcGajKc9a1dAJBTKr1i4GwYLgLk7WDvPtN1o1cAqS5DZ9CYzn3gZtT7BHEP4Qpsz24UELTncPY1Zsscsm3ajmX') 
-      expect(gateway2.confirmations_required).to eq(0) 
-      expect(gateway2.order_class).to eq("StraightServer::Order") 
-      expect(gateway2.name).to eq("second_gateway") 
+      expect(gateway2.pubkey).to eq('xpub6AH1Ymkkrwk3TaMrVrXBCpcGajKc9a1dAJBTKr1i4GwYLgLk7WDvPtN1o1cAqS5DZ9CYzn3gZtT7BHEP4Qpsz24UELTncPY1Zsscsm3ajmX')
+      expect(gateway2.confirmations_required).to eq(0)
+      expect(gateway2.order_class).to eq("StraightServer::Order")
+      expect(gateway2.name).to eq("second_gateway")
     end
 
     it "saves and retrieves last_keychain_id from the file in the .straight dir" do
+      @gateway = StraightServer::GatewayOnConfig.find_by_id(2)
       @gateway.check_signature = false
-      expect(File.read("#{ENV['HOME']}/.straight/default_last_keychain_id").to_i).to eq(0)
+      @gateway.save
+      expect(File.read("#{ENV['HOME']}/.straight/second_gateway_last_keychain_id").to_i).to eq(0)
       @gateway.update_last_keychain_id
       @gateway.save
-      expect(File.read("#{ENV['HOME']}/.straight/default_last_keychain_id").to_i).to eq(1)
+      expect(File.read("#{ENV['HOME']}/.straight/second_gateway_last_keychain_id").to_i).to eq(1)
 
-      expect(@gateway).to receive(:order_for_keychain_id).with(@order_for_keychain_id_args.merge({ keychain_id: 2})).once.and_return(@order_mock)
+      expect(@gateway).to receive(:new_order).with(@new_order_args.merge({ keychain_id: 2})).once.and_return(@order_mock)
       @gateway.create_order(amount: 1)
-      expect(File.read("#{ENV['HOME']}/.straight/default_last_keychain_id").to_i).to eq(2)
+      expect(File.read("#{ENV['HOME']}/.straight/second_gateway_last_keychain_id").to_i).to eq(2)
     end
-    
+
     it "searches for Gateway using regular ids when find_by_hashed_id method is called" do
       expect(StraightServer::GatewayOnConfig.find_by_hashed_id(1)).not_to be_nil
     end
 
+    it "set test mode `on` based on config" do
+      expect(@gateway.test_mode).to be true
+    end
+
+    it "set test mode `off`" do
+      @gateway = StraightServer::GatewayOnConfig.find_by_id(2)
+      expect(@gateway.test_mode).to be false
+    end
+
+    it "using testnet when test mode is enabled" do
+      @gateway = StraightServer::GatewayOnConfig.find_by_id(1)
+      expect(@gateway.blockchain_adapters).to_not be nil
+      expect(@gateway.blockchain_adapters.map(&:class)).to eq(@gateway.test_blockchain_adapters.map(&:class))
+    end
+
+    it "using testnet adapter that url given in config" do
+      @gateway = StraightServer::GatewayOnConfig.find_by_id(1)
+      expect(@gateway.blockchain_adapters).to_not be nil
+      expect(@gateway.test_blockchain_adapters.first.class).to eq(Straight::Blockchain::InsightAdapter)
+    end
+
+    it "fallback to another adapter if on previous one not ready for testnet" do
+      @gateway = StraightServer::GatewayOnConfig.find_by_id(1)
+      Straight::Blockchain::InsightAdapter.class_eval("def self.test_url=(val) @@test_url=val end")
+      Straight::Blockchain::InsightAdapter.test_url = nil
+      expect(@gateway.test_blockchain_adapters.first.class).to eq(Straight::Blockchain::MyceliumAdapter)
+    end
+
+    it "disable test mode manually" do
+      @gateway = StraightServer::GatewayOnConfig.find_by_id(1)
+      @gateway.test_mode = false
+      expect(@gateway.blockchain_adapters).to_not eq([Straight::Blockchain::MyceliumAdapter.testnet_adapter])
+    end
+
+    it "save test_last_keychain_id file with approciate data" do
+      gateway = StraightServer::GatewayOnConfig.find_by_id(1)
+      gateway.check_signature = false
+      gateway.save
+      expect(File.read("#{ENV['HOME']}/.straight/default_test_last_keychain_id").to_i).to eq(0)
+      gateway.update_last_keychain_id
+      gateway.save
+      expect(File.read("#{ENV['HOME']}/.straight/default_test_last_keychain_id").to_i).to eq(1)
+    end
+
   end
 
   describe "db based gateway" do
@@ -268,16 +307,17 @@ RSpec.describe StraightServer::Gateway do
         exchange_rate_adapter_names: ['Bitpay', 'Coinbase', 'Bitstamp']
       )
     end
-    
+
     it "saves and retrieves last_keychain_id from the db" do
       @gateway.check_signature = false
       @gateway.save
       expect(DB[:gateways][:name => 'default'][:last_keychain_id]).to eq(0)
       @gateway.update_last_keychain_id
       @gateway.save
+      @gateway.refresh
       expect(DB[:gateways][:name => 'default'][:last_keychain_id]).to eq(1)
 
-      expect(@gateway).to receive(:order_for_keychain_id).with(@order_for_keychain_id_args.merge({ keychain_id: 2})).once.and_return(@order_mock)
+      expect(@gateway).to receive(:new_order).with(@new_order_args.merge({ keychain_id: 2})).once.and_return(@order_mock)
       @gateway.create_order(amount: 1)
       expect(DB[:gateways][:name => 'default'][:last_keychain_id]).to eq(2)
     end
@@ -306,6 +346,94 @@ RSpec.describe StraightServer::Gateway do
       expect(StraightServer::GatewayOnDB.find_by_hashed_id(hashed_id)).to eq(@gateway)
     end
 
+    context "test mode" do
+
+      before(:each) do
+        @gateway.test_pubkey = "txpub"
+      end
+      
+      it "not activate after created" do
+        @gateway.save
+        expect(@gateway.test_mode).to be false
+      end
+
+      it "not using testnet adapter by default" do
+        @gateway.save
+        expect(@gateway.blockchain_adapters.map(&:class)).to_not eq(@gateway.test_blockchain_adapters.map(&:class))
+      end
+
+      it "activated if mode is specified explicity" do
+        @gateway.test_mode = true
+        @gateway.save
+        @gateway.refresh
+        expect(@gateway.test_mode).to be true
+        expect(@gateway.blockchain_adapters.map(&:class)).to eq(@gateway.test_blockchain_adapters.map(&:class))
+      end
+
+      it "enabled and not saved" do
+        @gateway.save
+        @gateway.enable_test_mode!
+        expect(@gateway.test_mode).to be true
+        @gateway.refresh
+        expect(@gateway.test_mode).to be false
+      end
+
+      it "enabled and saved" do
+        @gateway.save
+        @gateway.enable_test_mode!
+        expect(@gateway.test_mode).to be true
+        @gateway.refresh
+        expect(@gateway.test_mode).to be false
+      end
+
+      it "enabled and saved" do
+        @gateway[:test_mode] = false
+        expect(@gateway.test_mode).to eq false
+        @gateway.enable_test_mode!
+        @gateway.save
+        @gateway.refresh
+        expect(@gateway.test_mode).to be true
+      end
+      
+      it "field updates in mass assigment" do
+        @gateway.save
+        fields = {test_mode: true}
+        @gateway.update(fields)
+        @gateway.refresh
+        expect(@gateway.test_mode).to be true
+      end
+
+      it "update test_last_keychain_id" do
+        @gateway.check_signature = false
+        @gateway.enable_test_mode!
+        @gateway.save
+        @gateway.refresh
+
+        expect(@gateway).to receive(:new_order).with(@new_order_args).once.and_return(@order_mock)
+        @gateway.create_order(amount: 1)
+        expect(DB[:gateways][:name => 'default'][:test_last_keychain_id]).to eq(1)
+      end
+      
+      it "validate that test public key is provided when saving with test mode flag" do
+        @gateway = StraightServer::GatewayOnDB.new(
+          confirmations_required: 0,
+          pubkey:      'xpub-000',
+          test_mode:   true
+        )
+        expect(@gateway.valid?).to be false
+        expect(@gateway.errors[:test_pubkey]).to_not be_empty
+      end
+
+      it "doesn't require pubkey in test mode" do
+        @gateway = StraightServer::GatewayOnDB.new(
+          test_pubkey: 'xpub-000',
+          test_mode:   true,
+        )
+        expect(@gateway.valid?).to be true
+        @gateway.test_mode = false
+        expect(@gateway.valid?).to be false
+      end
+    end
   end
 
   describe "handling websockets" do