bitex_bot 0.3.7 → 0.4.0

data/spec/models/buy_closing_flow_spec.rb

@@ -1,102 +1,128 @@
 require 'spec_helper'
 
 describe BitexBot::BuyClosingFlow do
-  it "closes a single open position completely" do
+  let(:taker_settings) do
+    BitexBot::SettingsClass.new(
+      bitstamp: {
+        api_key: 'YOUR_API_KEY', secret: 'YOUR_API_SECRET', client_id: 'YOUR_BITSTAMP_USERNAME'
+      }
+    )
+  end
+
+  before(:each) do
+    BitexBot::Settings.stub(taker: taker_settings)
+    BitexBot::Robot.setup
+  end
+
+  it 'closes a single open position completely' do
     stub_bitstamp_sell
     open = create :open_buy
-    flow = BitexBot::BuyClosingFlow.close_open_positions
+    BitexBot::BuyClosingFlow.close_open_positions
+    flow = BitexBot::BuyClosingFlow.last
+
     open.reload.closing_flow.should == flow
+
     flow.open_positions.should == [open]
     flow.desired_price.should == 310
     flow.quantity.should == 2
+    flow.amount.should == 600
     flow.btc_profit.should be_nil
-    flow.usd_profit.should be_nil
+    flow.fiat_profit.should be_nil
+
     close = flow.close_positions.first
     close.order_id.should == '1'
     close.amount.should be_nil
     close.quantity.should be_nil
   end
-  
-  it "closes an aggregate of several open positions" do
+
+  it 'closes an aggregate of several open positions' do
     stub_bitstamp_sell
     open_one = create :tiny_open_buy
     open_two = create :open_buy
-    flow = BitexBot::BuyClosingFlow.close_open_positions
+    BitexBot::BuyClosingFlow.close_open_positions
+    flow = BitexBot::BuyClosingFlow.last
+
     close = flow.close_positions.first
+
     open_one.reload.closing_flow.should == flow
     open_two.reload.closing_flow.should == flow
+
     flow.open_positions.should == [open_one, open_two]
-    flow.desired_price.round(15).should == '310.497512437810945'.to_d
+    flow.desired_price.round(10).should == '310.4_975_124_378'.to_d
     flow.quantity.should == 2.01
+    flow.amount.should == 604
     flow.btc_profit.should be_nil
-    flow.usd_profit.should be_nil
-    close.order_id.should == '1'
-    close.amount.should be_nil
-    close.quantity.should be_nil
-  end
-  
-  it 'keeps trying to place a closed position on bitstamp errors' do
-    stub_bitstamp_sell
-    Bitstamp.orders.stub(:sell) do 
-      double(id: nil, error: {price: ['Ensure it is good']})
-    end
-    open = create :open_buy
-    flow = BitexBot::BuyClosingFlow.close_open_positions
-    open.reload.closing_flow.should == flow
-    flow.open_positions.should == [open]
-    flow.desired_price.should == 310
-    flow.quantity.should == 2
-    flow.btc_profit.should be_nil
-    flow.usd_profit.should be_nil
-    flow.close_positions.should be_empty
+    flow.fiat_profit.should be_nil
 
-    stub_bitstamp_user_transactions
-    stub_bitstamp_sell
-    flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
-    close = flow.close_positions.first
     close.order_id.should == '1'
     close.amount.should be_nil
     close.quantity.should be_nil
   end
-  
-  it "does not try to close if the amount is too low" do
+
+  it 'does not try to close if the amount is too low' do
     open = create :tiny_open_buy
     expect do
       BitexBot::BuyClosingFlow.close_open_positions.should be_nil
-    end.not_to change{ BitexBot::BuyClosingFlow.count }
+    end.not_to change { BitexBot::BuyClosingFlow.count }
   end
-  
-  it "does not try to close if there are no open positions" do
+
+  it 'does not try to close if there are no open positions' do
     expect do
       BitexBot::BuyClosingFlow.close_open_positions.should be_nil
-    end.not_to change{ BitexBot::BuyClosingFlow.count }
+    end.not_to change { BitexBot::BuyClosingFlow.count }
   end
-  
-  describe "when syncinc executed orders" do
+
+  describe 'when syncinc executed orders' do
     before(:each) do
       stub_bitstamp_sell
-      stub_bitstamp_user_transactions
+      stub_bitstamp_empty_user_transactions
       create :tiny_open_buy
       create :open_buy
     end
-  
-    it "syncs the executed orders, calculates profit" do
-      flow = BitexBot::BuyClosingFlow.close_open_positions
+
+    it 'syncs the executed orders, calculates profit' do
+      BitexBot::BuyClosingFlow.close_open_positions
+      flow = BitexBot::BuyClosingFlow.last
       stub_bitstamp_orders_into_transactions
+
       flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+
       close = flow.close_positions.last
-      close.amount.should == '624.105'.to_d
+      close.amount.should == 624.105
       close.quantity.should == 2.01
+
       flow.should be_done
-      flow.btc_profit.should == 0
-      flow.usd_profit.should == '20.105'.to_d
+      flow.btc_profit.should be_zero
+      flow.fiat_profit.should == 20.105
     end
-  
-    it "retries closing at a lower price every minute" do
-      flow = BitexBot::BuyClosingFlow.close_open_positions
+
+    context 'with other fx rate and closed open positions' do
+      let(:fx_rate) { 10.to_d }
+      let(:flow) { subject.class.last }
+      let(:positions_balance_amount) { flow.positions_balance_amount - flow.open_positions.sum(:amount) }
+
+      before(:each) do
+        BitexBot::Settings.stub(fx_rate: fx_rate)
+        subject.class.close_open_positions
+
+        stub_bitstamp_orders_into_transactions
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end
+
+      it 'syncs the executed orders, calculates profit with other fx rate' do
+        flow.should be_done
+        flow.btc_profit.should be_zero
+        flow.fiat_profit.should eq positions_balance_amount
+      end
+    end
+
+    it 'retries closing at a lower price every minute' do
+      BitexBot::BuyClosingFlow.close_open_positions
+      flow = BitexBot::BuyClosingFlow.last
+
       expect do
         flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
-      end.not_to change{ BitexBot::CloseBuy.count }
+      end.not_to change { BitexBot::CloseBuy.count }
       flow.should_not be_done
 
       # Immediately calling sync again does not try to cancel the ask.
@@ -110,18 +136,19 @@ describe BitexBot::BuyClosingFlow do
       Bitstamp.orders.all.size.should == 1
       expect do
         flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
-      end.not_to change{ BitexBot::CloseBuy.count }
-      Bitstamp.orders.all.size.should == 0
+      end.not_to change { BitexBot::CloseBuy.count }
+      Bitstamp.orders.all.size.should be_zero
       flow.should_not be_done
-      
+
       # Next time we try to sync_closed_positions the flow
       # detects the previous close_buy was cancelled correctly so
       # it syncs it's total amounts and tries to place a new one.
       expect do
         flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
-      end.to change{ BitexBot::CloseBuy.count }.by(1)
+      end.to change { BitexBot::CloseBuy.count }.by(1)
+
       flow.close_positions.first.tap do |close|
-        close.amount.should == '312.0525'.to_d
+        close.amount.should == 312.0_525
         close.quantity.should == 1.005
       end
 
@@ -130,34 +157,36 @@ describe BitexBot::BuyClosingFlow do
       stub_bitstamp_orders_into_transactions
       flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
       flow.close_positions.last.tap do |close|
-        close.amount.should == '312.02235'.to_d
+        close.amount.should == 312.02_235
         close.quantity.should == 1.005
       end
       flow.should be_done
-      flow.btc_profit.should == 0
-      flow.usd_profit.should == '20.07485'.to_d
+      flow.btc_profit.should be_zero
+      flow.fiat_profit.should == 20.07_485
     end
-    
-    it "does not retry for an amount less than minimum_for_closing" do
-      flow = BitexBot::BuyClosingFlow.close_open_positions
 
+    it 'does not retry for an amount less than minimum_for_closing' do
+      BitexBot::BuyClosingFlow.close_open_positions
+      flow = BitexBot::BuyClosingFlow.last
       stub_bitstamp_orders_into_transactions(ratio: 0.999)
       Bitstamp.orders.all.first.cancel!
 
       expect do
         flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
-      end.not_to change{ BitexBot::CloseBuy.count }
+      end.not_to change { BitexBot::CloseBuy.count }
 
       flow.should be_done
-      flow.btc_profit.should == 0.00201
-      flow.usd_profit.should == '19.480895'.to_d
+      flow.btc_profit.should == 0.00_201
+      flow.fiat_profit.should == 19.480_895
     end
-    
-    it "can lose USD if price had to be dropped dramatically" do
+
+    it 'can lose USD if price had to be dropped dramatically' do
       # This flow is forced to sell the original BTC quantity for less, thus regaining
       # less USD than what was spent on bitex.
-      flow = BitexBot::BuyClosingFlow.close_open_positions
-      60.times do 
+      BitexBot::BuyClosingFlow.close_open_positions
+      flow = BitexBot::BuyClosingFlow.last
+
+      60.times do
         Timecop.travel 60.seconds.from_now
         flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
       end
@@ -165,10 +194,50 @@ describe BitexBot::BuyClosingFlow do
       stub_bitstamp_orders_into_transactions
 
       flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
-
       flow.reload.should be_done
-      flow.btc_profit.should == 0
-      flow.usd_profit.should == '-34.165'.to_d
+      flow.btc_profit.should be_zero
+      flow.fiat_profit.should == -34.165
+    end
+  end
+
+  describe 'when there are errors placing the closing order' do
+    it 'keeps trying to place a closed position on bitstamp errors' do
+      BitstampApiWrapper.stub(send_order: nil)
+      BitstampApiWrapper.stub(find_lost: nil)
+
+      open = create :open_buy
+      expect do
+        BitexBot::BuyClosingFlow.close_open_positions
+      end.to raise_exception(OrderNotFound)
+      flow = BitexBot::BuyClosingFlow.last
+
+      open.reload.closing_flow.should == flow
+
+      flow.open_positions.should == [open]
+      flow.desired_price.should == 310
+      flow.quantity.should == 2
+      flow.btc_profit.should be_nil
+      flow.fiat_profit.should be_nil
+      flow.close_positions.should be_empty
+    end
+
+    it 'retries until it finds the lost order' do
+      BitstampApiWrapper.stub(send_order: nil)
+      BitstampApiWrapper.stub(:orders) do
+        [BitstampApiWrapper::Order.new(1, :sell, 310, 2.5, 1.minute.ago.to_i)]
+      end
+
+      open = create(:open_buy)
+      BitexBot::BuyClosingFlow.close_open_positions
+      flow = BitexBot::BuyClosingFlow.last
+
+      flow.close_positions.should_not be_empty
+      flow.close_positions.first do |position|
+        position.id.should eq 1234
+        position.type.should eq 1
+        position.amount.should eq 1000
+        position.price.should eq 2000
+      end
     end
   end
 end

data/spec/models/buy_opening_flow_spec.rb

@@ -1,91 +1,141 @@
 require 'spec_helper'
 
 describe BitexBot::BuyOpeningFlow do
-  before(:each) do
-    Bitex.api_key = "valid_key"
-  end
-  let(:store){ BitexBot::Store.create }
+  before(:each) { Bitex.api_key = 'valid_key' }
+
+  let(:store) { BitexBot::Store.create }
 
   it { should validate_presence_of :status }
   it { should validate_presence_of :price }
   it { should validate_presence_of :value_to_use }
   it { should validate_presence_of :order_id }
-  it { should(validate_inclusion_of(:status)
-    .in_array(BitexBot::BuyOpeningFlow.statuses)) }
+  it { should(validate_inclusion_of(:status).in_array(BitexBot::BuyOpeningFlow.statuses)) }
 
-  describe "when creating a buying flow" do
-    it "spends 50 usd" do
+  describe 'when creating a buying flow' do
+    it 'spends 50 usd' do
       stub_bitex_orders
       BitexBot::Settings.stub(time_to_live: 3,
         buying: double(amount_to_spend_per_order: 50, profit: 0))
 
       flow = BitexBot::BuyOpeningFlow.create_for_market(100,
-        bitstamp_order_book_stub['bids'], bitstamp_transactions_stub, 0.5, 0.25, store)
-      
+        bitstamp_api_wrapper_order_book.bids, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+        store)
+
+      flow.order_id.should == 12345
       flow.value_to_use.should == 50
       flow.price.should <= flow.suggested_closing_price
-      flow.price.round(14).should == "19.85074626865672".to_d
+      flow.price.round(14).should == '19.85074626865672'.to_d
       flow.suggested_closing_price.should == 20
-      flow.order_id.should == 12345
     end
 
-    it "spends 100 usd" do
+    let(:order_id) { 12_345 }
+    let(:usd_price) { '14.888_059_701_492'.to_d }
+    let(:suggested_closing_price) { 15.to_d }
+    let(:amount_to_spend) { 100.to_d }
+    let(:btc_balance) { 100_000.to_d }
+    let(:maker_fee) { 0.5.to_d }
+    let(:taker_fee) { 0.25.to_d }
+    let(:order_book) { bitstamp_api_wrapper_order_book.bids }
+    let(:transactions) { bitstamp_api_wrapper_transactions_stub }
+
+    it 'spends 100 usd' do
+      BitexBot::Settings.stub(
+        time_to_live: 3,
+        buying: double(amount_to_spend_per_order: amount_to_spend, profit: 0)
+      )
       stub_bitex_orders
-      BitexBot::Settings.stub(time_to_live: 3,
-        buying: double(amount_to_spend_per_order: 100, profit: 0))
 
-      flow = BitexBot::BuyOpeningFlow.create_for_market(100000,
-        bitstamp_order_book_stub['bids'], bitstamp_transactions_stub, 0.5, 0.25, store)
-      flow.value_to_use.should == 100
-      flow.price.should <= flow.suggested_closing_price
-      flow.price.should == "14.88805970149254".to_d
-      flow.suggested_closing_price.should == 15
-      flow.order_id.should == 12345
+      flow =
+        BitexBot::BuyOpeningFlow.create_for_market(
+          btc_balance,
+          order_book,
+          transactions,
+          maker_fee,
+          taker_fee,
+          store
+        )
+
+      flow.order_id.should eq order_id
+      flow.value_to_use.should eq amount_to_spend
+      flow.price.should.should <= flow.suggested_closing_price
+      flow.price.truncate(12).should eq usd_price
+      flow.suggested_closing_price.should eq suggested_closing_price
+    end
+
+    let(:other_fx_rate) { 10.to_d }
+
+    it 'spends 100 usd with other fx_rate' do
+      BitexBot::Settings.stub(
+        fx_rate: other_fx_rate,
+        time_to_live: 3,
+        buying: double(amount_to_spend_per_order: amount_to_spend, profit: 0)
+      )
+      stub_bitex_orders
+
+      flow =
+        BitexBot::BuyOpeningFlow.create_for_market(
+          btc_balance,
+          order_book,
+          transactions,
+          maker_fee,
+          taker_fee,
+          store
+        )
+
+      flow.order_id.should eq order_id
+      flow.value_to_use.should eq amount_to_spend
+      flow.price.should <= flow.suggested_closing_price * other_fx_rate
+      flow.price.truncate(11).should eq usd_price * other_fx_rate
+      flow.suggested_closing_price.should eq suggested_closing_price
     end
-    
-    it "lowers the price to pay on bitex to take a profit" do
+
+    it 'lowers the price to pay on bitex to take a profit' do
       stub_bitex_orders
       BitexBot::Settings.stub(time_to_live: 3,
-        buying: double(amount_to_spend_per_order: 100, profit: 50))
+        buying: double(amount_to_spend_per_order: 100, profit: 50.to_d))
 
       flow = BitexBot::BuyOpeningFlow.create_for_market(100000,
-        bitstamp_order_book_stub['bids'], bitstamp_transactions_stub, 0.5, 0.25, store)
+        bitstamp_api_wrapper_order_book.bids, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+        store)
+
+      flow.order_id.should == 12345
       flow.value_to_use.should == 100
       flow.price.should <= flow.suggested_closing_price
-      flow.price.round(15).should == "7.44402985074627".to_d
+      flow.price.should == '7.44402985074627'.to_d
       flow.suggested_closing_price.should == 15
-      flow.order_id.should == 12345
     end
-    
-    it "fails when there is a problem placing the bid on bitex" do
-      Bitex::Bid.stub(:create!) do 
-        raise StandardError.new("Cannot Create")
-      end
+
+    it 'fails when there is a problem placing the bid on bitex' do
+      Bitex::Bid.stub(:create!) { raise StandardError.new('Cannot Create') }
 
       BitexBot::Settings.stub(time_to_live: 3,
         buying: double(amount_to_spend_per_order: 100, profit: 0))
 
       expect do
         flow = BitexBot::BuyOpeningFlow.create_for_market(100000,
-          bitstamp_order_book_stub['bids'], bitstamp_transactions_stub, 0.5, 0.25, store)
+          bitstamp_api_wrapper_order_book.bids, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+          store)
+
         flow.should be_nil
         BitexBot::BuyOpeningFlow.count.should == 0
       end.to raise_exception(BitexBot::CannotCreateFlow)
     end
-    
-    it "fails when there are not enough bitcoin to sell in the other exchange" do
+
+    it 'fails when there are not enough bitcoin to sell in the other exchange' do
       stub_bitex_orders
       BitexBot::Settings.stub(time_to_live: 3,
         buying: double(amount_to_spend_per_order: 100, profit: 0))
 
       expect do
         flow = BitexBot::BuyOpeningFlow.create_for_market(1,
-          bitstamp_order_book_stub['bids'], bitstamp_transactions_stub, 0.5, 0.25, store)
+          bitstamp_api_wrapper_order_book.bids, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+          store)
+
         flow.should be_nil
         BitexBot::BuyOpeningFlow.count.should == 0
       end.to raise_exception(BitexBot::CannotCreateFlow)
     end
-    
+
     it 'prioritizes profit from store' do
       store = BitexBot::Store.new(buying_profit: 0.5)
       stub_bitex_orders
@@ -93,20 +143,23 @@ describe BitexBot::BuyOpeningFlow do
         buying: double(amount_to_spend_per_order: 50, profit: 0))
 
       flow = BitexBot::BuyOpeningFlow.create_for_market(100,
-        bitstamp_order_book_stub['bids'], bitstamp_transactions_stub, 0.5, 0.25, store)
-      
-      flow.price.round(13).should == "19.7514925373134".to_d
+        bitstamp_api_wrapper_order_book.bids, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+        store)
+
+      flow.price.round(13).should == '19.7514925373134'.to_d
     end
   end
-  
-  describe "when fetching open positions" do
-    let(:flow){ create(:buy_opening_flow) }
+
+  describe 'when fetching open positions' do
+    let(:flow) { create(:buy_opening_flow) }
 
     it 'only gets buys' do
       flow.order_id.should == 12345
       stub_bitex_transactions
+
       expect do
         all = BitexBot::BuyOpeningFlow.sync_open_positions
+
         all.size.should == 1
         all.first.tap do |o|
           o.price == 300.0
@@ -115,9 +168,9 @@ describe BitexBot::BuyOpeningFlow do
           o.transaction_id.should == 12345678
           o.opening_flow.should == flow
         end
-      end.to change{ BitexBot::OpenBuy.count }.by(1)
+      end.to change { BitexBot::OpenBuy.count }.by(1)
     end
-    
+
     it 'does not register the same buy twice' do
       flow.order_id.should == 12345
       stub_bitex_transactions
@@ -125,40 +178,57 @@ describe BitexBot::BuyOpeningFlow do
       BitexBot::OpenBuy.count.should == 1
       Timecop.travel 1.second.from_now
       stub_bitex_transactions(build(:bitex_buy, id: 23456))
+
       expect do
         news = BitexBot::BuyOpeningFlow.sync_open_positions
         news.first.transaction_id.should == 23456
-      end.to change{ BitexBot::OpenBuy.count }.by(1)
+      end.to change { BitexBot::OpenBuy.count }.by(1)
     end
-    
-    it 'does not register litecoin buys' do
+
+    it 'does not register buys from another order book' do
       flow.order_id.should == 12345
-      Bitex::Trade.stub(all: [build(:bitex_buy, id: 23456, specie: :ltc)])
+      Bitex::Trade.stub(all: [build(:bitex_buy, id: 23456, order_book: :btc_ars)])
+
       expect do
         BitexBot::BuyOpeningFlow.sync_open_positions.should be_empty
-      end.not_to change{ BitexBot::OpenBuy.count }
+      end.not_to change { BitexBot::OpenBuy.count }
       BitexBot::OpenBuy.count.should == 0
     end
-    
+
     it 'does not register buys from unknown bids' do
       stub_bitex_transactions
+
       expect do
         BitexBot::BuyOpeningFlow.sync_open_positions.should be_empty
-      end.not_to change{ BitexBot::OpenBuy.count }
+      end.not_to change { BitexBot::OpenBuy.count }
     end
   end
-  
+
   it 'cancels the associated bitex bid' do
     stub_bitex_orders
     BitexBot::Settings.stub(time_to_live: 3,
       buying: double(amount_to_spend_per_order: 50, profit: 0))
 
     flow = BitexBot::BuyOpeningFlow.create_for_market(100,
-      bitstamp_order_book_stub['bids'], bitstamp_transactions_stub, 0.5, 0.25, store)
-    
+      bitstamp_api_wrapper_order_book.bids, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+      store)
+
     flow.finalise!
     flow.should be_settling
     flow.finalise!
     flow.should be_finalised
   end
+
+  it 'order has expected order book' do
+    stub_bitex_orders
+    BitexBot::Settings.stub(time_to_live: 3,
+      buying: double(amount_to_spend_per_order: 50, profit: 0))
+
+    flow = subject.class.create_for_market(100,
+      bitstamp_api_wrapper_order_book.bids, bitstamp_api_wrapper_transactions_stub, 0.5, 0.25,
+      store)
+
+    order = subject.class.order_class.find(flow.order_id)
+    order.order_book.should eq BitexBot::Settings.maker_settings.order_book
+  end
 end

data/spec/models/order_book_simulator_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe BitexBot::OrderBookSimulator do
   describe 'when buying on bitex to sell somewhere else' do
     def simulate(volatility, amount)
-      BitexBot::OrderBookSimulator.run(volatility, bitstamp_transactions_stub,
-        bitstamp_order_book_stub['bids'], amount, nil)
+      BitexBot::OrderBookSimulator.run(volatility, bitstamp_api_wrapper_transactions_stub,
+        bitstamp_api_wrapper_order_book.bids, amount, nil)
     end
 
     it 'gets the safest price' do
@@ -14,15 +14,15 @@ describe BitexBot::OrderBookSimulator do
     it 'adjusts for medium volatility' do
       simulate(3, 20).should == 25
     end
-    
+
     it 'adjusts for high volatility' do
       simulate(6, 20).should == 20
     end
-  
+
     it 'big orders dig deep' do
       simulate(0, 180).should == 15
     end
-    
+
     it 'big orders with high volatility' do
       simulate(6, 100).should == 10
     end
@@ -34,8 +34,8 @@ describe BitexBot::OrderBookSimulator do
 
   describe 'when selling on bitex to buy somewhere else' do
     def simulate(volatility, quantity)
-      BitexBot::OrderBookSimulator.run(volatility, bitstamp_transactions_stub,
-        bitstamp_order_book_stub['asks'], nil, quantity)
+      BitexBot::OrderBookSimulator.run(volatility, bitstamp_api_wrapper_transactions_stub,
+        bitstamp_api_wrapper_order_book.asks, nil, quantity)
     end
 
     it 'gets the safest price' do
@@ -45,15 +45,15 @@ describe BitexBot::OrderBookSimulator do
     it 'adjusts for medium volatility' do
       simulate(3, 2).should == 15
     end
-    
+
     it 'adjusts for high volatility' do
       simulate(6, 2).should == 25
     end
-  
+
     it 'big orders dig deep' do
       simulate(0, 8).should == 25
     end
-    
+
     it 'big orders with high volatility dig deep' do
       simulate(6, 6).should == 30
     end