bitex_bot 0.0.1

data/spec/models/buy_opening_flow_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe BitexBot::BuyOpeningFlow do
+  before(:each) do
+    Bitex.api_key = "valid_key"
+  end
+
+  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(ensure_inclusion_of(:status)
+    .in_array(BitexBot::BuyOpeningFlow.statuses)) }
+
+  describe "when creating a buying flow" do
+    it "spends 50 usd" do
+      stub_bitex_bid_create
+      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)
+      
+      flow.value_to_use.should == 50
+      flow.price.should <= flow.suggested_closing_price
+      flow.price.should == "19.85074626865672".to_d
+      flow.suggested_closing_price.should == 20
+      flow.order_id.should == 12345
+    end
+
+    it "spends 100 usd" do
+      stub_bitex_bid_create
+      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)
+      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
+    end
+    
+    it "lowers the price to pay on bitex to take a profit" do
+      stub_bitex_bid_create
+      BitexBot::Settings.stub(time_to_live: 3,
+        buying: double(amount_to_spend_per_order: 100, profit: 50))
+
+      flow = BitexBot::BuyOpeningFlow.create_for_market(100000,
+        bitstamp_order_book_stub['bids'], bitstamp_transactions_stub, 0.5, 0.25)
+      flow.value_to_use.should == 100
+      flow.price.should <= flow.suggested_closing_price
+      flow.price.should == "7.444029850746269".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
+
+      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)
+        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
+      stub_bitex_bid_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(1,
+          bitstamp_order_book_stub['bids'], bitstamp_transactions_stub, 0.5, 0.25)
+        flow.should be_nil
+        BitexBot::BuyOpeningFlow.count.should == 0
+      end.to raise_exception(BitexBot::CannotCreateFlow)
+    end
+  end
+  
+  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
+          o.amount == 600.0
+          o.quantity == 2
+          o.transaction_id.should == 12345678
+          o.opening_flow.should == flow
+        end
+      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
+      BitexBot::BuyOpeningFlow.sync_open_positions
+      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
+    
+    it 'does not register litecoin buys' do
+      flow.order_id.should == 12345
+      Bitex::Transaction.stub(all: [build(:bitex_buy, id: 23456, specie: :ltc)])
+      expect do
+        BitexBot::BuyOpeningFlow.sync_open_positions.should be_empty
+      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
+  end
+  
+  it 'cancels the associated bitex bid' do
+    stub_bitex_bid_create
+    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)
+    
+    flow.finalise!
+    flow.should be_settling
+    flow.finalise!
+    flow.should be_settling
+    Bitex::Order.stub(active: [])
+    flow.finalise!
+    flow.should be_finalised
+  end
+end

data/spec/models/order_book_simulator_spec.rb

@@ -0,0 +1,57 @@
+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)
+    end
+
+    it 'gets the safest price' do
+      simulate(0, 20).should == 30
+    end
+
+    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
+  end
+
+  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)
+    end
+
+    it 'gets the safest price' do
+      simulate(0, 2).should == 10
+    end
+
+    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
+  end
+end

data/spec/models/robot_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe BitexBot::Robot do
+  before(:each) do
+    BitexBot::Settings.stub(
+      time_to_live: 10,
+      buying: double(
+        amount_to_spend_per_order: 50,
+        profit: 0),
+      selling: double(
+        quantity_to_sell_per_order: 1,
+        profit: 0),
+      mailer: double(
+        from: 'test@test.com',
+        to: 'test@test.com',
+        method: :test,
+        options: {}
+      )
+    )
+    Bitex.api_key = "valid_key"
+    Bitex::Profile.stub(get: {fee: 0.5})
+    stub_bitex_bid_create
+    stub_bitex_ask_create
+    stub_bitstamp_sell
+    stub_bitstamp_buy
+    stub_bitstamp_balance
+    stub_bitstamp_order_book
+    stub_bitstamp_transactions
+    stub_bitstamp_user_transactions
+  end
+  let(:bot){ BitexBot::Robot.new }
+
+  it 'Starts out by creating opening flows that timeout' do
+    bot.trade!
+    stub_bitex_transactions
+    buying = BitexBot::BuyOpeningFlow.last
+    selling = BitexBot::SellOpeningFlow.last
+
+    Timecop.travel 10.minutes.from_now
+    bot.trade!
+ 
+    buying.reload.should be_settling
+    selling.reload.should be_settling
+
+    Bitex::Order.stub(active: [])
+    bot.trade!
+    buying.reload.should be_finalised
+    selling.reload.should be_finalised
+  end
+  
+  it 'creates alternating opening flows' do
+    Bitex::Transaction.stub(all: [])
+    bot.trade!
+    BitexBot::BuyOpeningFlow.active.count.should == 1
+    Timecop.travel 2.seconds.from_now
+    bot.trade!
+    BitexBot::BuyOpeningFlow.active.count.should == 1
+    Timecop.travel 5.seconds.from_now
+    bot.trade!
+    BitexBot::BuyOpeningFlow.active.count.should == 2
+    
+    stub_bitex_transactions
+    Bitex::Order.stub(active: [])
+    Timecop.travel 5.seconds.from_now
+    bot.trade!
+    BitexBot::BuyOpeningFlow.active.count.should == 1
+    Timecop.travel 5.seconds.from_now
+    bot.trade!
+    BitexBot::BuyOpeningFlow.active.count.should == 0
+  end
+
+  it 'does not place new opening flows until all closing flows are done' do
+    bot.trade!
+    stub_bitex_transactions
+    Bitex::Order.stub(active: [])
+    expect do
+      bot.trade!
+    end.to change{ BitexBot::BuyClosingFlow.count }.by(1)
+
+    Timecop.travel 15.seconds.from_now
+    bot.trade!
+    bot.should be_active_closing_flows
+    bot.should_not be_active_opening_flows
+
+    stub_bitstamp_orders_into_transactions
+    expect do
+      bot.trade!
+      bot.should_not be_active_closing_flows
+    end.to change{ BitexBot::BuyOpeningFlow.count }.by(1)
+  end
+ 
+  it 'notifies exceptions and sleeps' do
+    Bitstamp.stub(:balance) do
+      raise StandardError.new('oh moova')
+    end
+    bot.trade!
+    Mail::TestMailer.deliveries.count.should == 1
+  end
+
+  #it 'goes through all the motions buying and selling' do
+  #  pending
+  #end
+end

data/spec/models/sell_closing_flow_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe BitexBot::SellClosingFlow do
+  it "closes a single open position completely" do
+    stub_bitstamp_buy
+    open = create :open_sell
+    flow = BitexBot::SellClosingFlow.close_open_positions
+    open.reload.closing_flow.should == flow
+    flow.open_positions.should == [open]
+    flow.desired_price.should == 290
+    flow.quantity.should == 2
+    flow.amount.should == 600
+    flow.btc_profit.should be_nil
+    flow.usd_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
+    stub_bitstamp_buy
+    open_one = create :tiny_open_sell
+    open_two = create :open_sell
+    flow = BitexBot::SellClosingFlow.close_open_positions
+    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.should == '290.497512437810945273631840797'.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 "does not try to close if the amount is too low" do
+    open = create :tiny_open_sell
+    expect do
+      BitexBot::SellClosingFlow.close_open_positions.should be_nil
+    end.not_to change{ BitexBot::SellClosingFlow.count }
+  end
+  
+  it "does not try to close if there are no open positions" do
+    expect do
+      BitexBot::SellClosingFlow.close_open_positions.should be_nil
+    end.not_to change{ BitexBot::SellClosingFlow.count }
+  end
+  
+  describe "when syncinc executed orders" do
+    before(:each) do
+      stub_bitstamp_buy
+      stub_bitstamp_user_transactions
+      create :tiny_open_sell
+      create :open_sell
+    end
+  
+    it "syncs the executed orders, calculates profit" do
+      flow = BitexBot::SellClosingFlow.close_open_positions
+      stub_bitstamp_orders_into_transactions
+      flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      close = flow.close_positions.last
+      close.amount.should == 583.9
+      close.quantity.should == 2.01
+      flow.should be_done
+      flow.btc_profit.should == 0
+      flow.usd_profit.should == 20.1
+    end
+  
+    it "retries closing at a higher price every minute" do
+      flow = BitexBot::SellClosingFlow.close_open_positions
+      expect do
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end.not_to change{ BitexBot::CloseSell.count }
+      flow.should_not be_done
+
+      # Immediately calling sync again does not try to cancel the ask.
+      flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      Bitstamp.orders.all.size.should == 1
+
+      # Partially executes order, and 61 seconds after that
+      # sync_closed_positions tries to cancel it.
+      stub_bitstamp_orders_into_transactions(ratio: 0.5)
+      Timecop.travel 61.seconds.from_now
+      Bitstamp.orders.all.size.should == 1
+      expect do
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end.not_to change{ BitexBot::CloseSell.count }
+      Bitstamp.orders.all.size.should == 0
+      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::CloseSell.count }.by(1)
+      flow.close_positions.first.tap do |close|
+        close.amount.should == 291.95
+        close.quantity.should == 1.005
+      end
+
+      # The second ask is executed completely so we can wrap it up and consider
+      # this closing flow done.
+      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 == 291.95
+        close.quantity.should == '1.004930813120933'.to_d
+      end
+      flow.should be_done
+      flow.btc_profit.should == '-0.000069186879067'.to_d
+      flow.usd_profit.should == 20.1
+    end
+    
+    it "does not retry for an amount less than minimum_for_closing" do
+      flow = BitexBot::SellClosingFlow.close_open_positions
+
+      20.times do 
+        Timecop.travel 60.seconds.from_now
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end
+
+      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::CloseSell.count }
+
+      flow.should be_done
+      flow.btc_profit.should == '-0.015739962920125'.to_d
+      flow.usd_profit.should == '20.6839'.to_d
+    end
+    
+    it "can lose BTC if price had to be raised dramatically" do
+      # This flow is forced to spend the original USD amount paying more than
+      # expected, thus regaining less BTC than what was sold on bitex.
+      flow = BitexBot::SellClosingFlow.close_open_positions
+      60.times do 
+        Timecop.travel 60.seconds.from_now
+        flow.sync_closed_positions(Bitstamp.orders.all, Bitstamp.user_transactions.all)
+      end
+
+      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.117278093149271".to_d
+      flow.usd_profit.should == "20.1".to_d
+      close = flow.close_positions.last
+      (close.amount / close.quantity)
+        .should == '308.497512437810935201007569945345172662'.to_d
+    end
+  end
+end

data/spec/models/sell_opening_flow_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe BitexBot::SellOpeningFlow do
+  before(:each) do
+    Bitex.api_key = "valid_key"
+  end
+
+  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(ensure_inclusion_of(:status)
+    .in_array(BitexBot::SellOpeningFlow.statuses)) }
+
+  describe "when creating a selling flow" do
+    it "sells 2 bitcoin" do
+      stub_bitex_ask_create
+      BitexBot::Settings.stub(time_to_live: 3,
+        selling: double(quantity_to_sell_per_order: 2, profit: 0))
+
+      flow = BitexBot::SellOpeningFlow.create_for_market(1000,
+        bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25)
+      
+      flow.value_to_use.should == 2
+      flow.price.should >= flow.suggested_closing_price
+      flow.price.should == "20.15037593984962".to_d
+      flow.suggested_closing_price.should == 20
+      flow.order_id.should == 12345
+    end
+
+    it "sells 4 bitcoin" do
+      stub_bitex_ask_create
+      BitexBot::Settings.stub(time_to_live: 3,
+        selling: double(quantity_to_sell_per_order: 4, profit: 0))
+
+      flow = BitexBot::SellOpeningFlow.create_for_market(1000,
+        bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25)
+      
+      flow.value_to_use.should == 4
+      flow.price.should >= flow.suggested_closing_price
+      flow.price.should == "25.18796992481203".to_d
+      flow.suggested_closing_price.should == 25
+      flow.order_id.should == 12345
+    end
+    
+    it "raises the price to charge on bitex to take a profit" do
+      stub_bitex_ask_create
+      BitexBot::Settings.stub(time_to_live: 3,
+        selling: double(quantity_to_sell_per_order: 4, profit: 50))
+
+      flow = BitexBot::SellOpeningFlow.create_for_market(1000,
+        bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25)
+      
+      flow.value_to_use.should == 4
+      flow.price.should >= flow.suggested_closing_price
+      flow.price.should == "37.78195488721804".to_d
+      flow.suggested_closing_price.should == 25
+      flow.order_id.should == 12345
+    end
+    
+    it "fails when there is a problem placing the ask on bitex" do
+      Bitex::Ask.stub(:create!) do 
+        raise StandardError.new("Cannot Create")
+      end
+
+      BitexBot::Settings.stub(time_to_live: 3,
+        selling: double(quantity_to_sell_per_order: 4, profit: 50))
+
+      expect do
+        flow = BitexBot::SellOpeningFlow.create_for_market(100000,
+          bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25)
+        flow.should be_nil
+        BitexBot::SellOpeningFlow.count.should == 0
+      end.to raise_exception(BitexBot::CannotCreateFlow)
+    end
+    
+    it "fails when there are not enough USD to re-buy in the other exchange" do
+      stub_bitex_bid_create
+      BitexBot::Settings.stub(time_to_live: 3,
+        selling: double(quantity_to_sell_per_order: 4, profit: 50))
+
+      expect do
+        flow = BitexBot::SellOpeningFlow.create_for_market(1,
+          bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25)
+        flow.should be_nil
+        BitexBot::SellOpeningFlow.count.should == 0
+      end.to raise_exception(BitexBot::CannotCreateFlow)
+    end
+  end
+  
+  describe "when fetching open positions" do
+    let(:flow){ create(:sell_opening_flow) }
+
+    it 'only gets sells' do
+      flow.order_id.should == 12345
+      stub_bitex_transactions
+      expect do
+        all = BitexBot::SellOpeningFlow.sync_open_positions
+        all.size.should == 1
+        all.first.tap do |o|
+          o.price.should == 300.0
+          o.amount.should == 600.0
+          o.quantity.should == 2
+          o.transaction_id.should == 12345678
+          o.opening_flow.should == flow
+        end
+      end.to change{ BitexBot::OpenSell.count }.by(1)
+    end
+    
+    it 'does not register the same buy twice' do
+      flow.order_id.should == 12345
+      stub_bitex_transactions
+      BitexBot::SellOpeningFlow.sync_open_positions
+      BitexBot::OpenSell.count.should == 1
+      Timecop.travel 1.second.from_now
+      stub_bitex_transactions(build(:bitex_sell, id: 23456))
+      expect do
+        news = BitexBot::SellOpeningFlow.sync_open_positions
+        news.first.transaction_id.should == 23456
+      end.to change{ BitexBot::OpenSell.count }.by(1)
+    end
+    
+    it 'does not register litecoin buys' do
+      flow.order_id.should == 12345
+      Bitex::Transaction.stub(all: [build(:bitex_sell, id: 23456, specie: :ltc)])
+      expect do
+        BitexBot::SellOpeningFlow.sync_open_positions.should be_empty
+      end.not_to change{ BitexBot::OpenSell.count }
+      BitexBot::OpenSell.count.should == 0
+    end
+    
+    it 'does not register buys from unknown bids' do
+      stub_bitex_transactions
+      expect do
+        BitexBot::SellOpeningFlow.sync_open_positions.should be_empty
+      end.not_to change{ BitexBot::OpenSell.count }
+    end
+  end
+  
+  it 'cancels the associated bitex bid' do
+    stub_bitex_ask_create
+    BitexBot::Settings.stub(time_to_live: 3,
+      selling: double(quantity_to_sell_per_order: 4, profit: 50))
+
+    flow = BitexBot::SellOpeningFlow.create_for_market(1000,
+      bitstamp_order_book_stub['asks'], bitstamp_transactions_stub, 0.5, 0.25)
+    
+    flow.finalise!
+    flow.should be_settling
+    flow.finalise!
+    flow.should be_settling
+    Bitex::Order.stub(active: [])
+    flow.finalise!
+    flow.should be_finalised
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'bitex_bot'
+require 'factory_girl'
+require 'database_cleaner'
+require 'shoulda/matchers'
+require 'timecop'
+FactoryGirl.find_definitions
+
+Dir[File.dirname(__FILE__) + '/support/*.rb'].each {|file| require file }
+
+# Automatically do rake db:test:prepare
+ActiveRecord::Migration.maintain_test_schema!
+
+# Transactional fixtures do not work with Selenium tests, because Capybara
+# uses a separate server thread, which the transactions would be hidden
+# from. We hence use DatabaseCleaner to truncate our test database.
+DatabaseCleaner.strategy = :truncation
+
+RSpec.configure do |config|
+  config.include(FactoryGirl::Syntax::Methods)
+  config.mock_with :rspec do |mocks|
+    mocks.yield_receiver_to_any_instance_implementation_blocks = true
+    mocks.syntax = [:expect, :should]
+  end
+  config.expect_with :rspec do |c|
+    c.syntax = [:expect, :should]
+  end
+  
+  config.before(:all) do
+    BitexBot::Robot.logger = Logger.new('/dev/null')
+    BitexBot::Robot.test_mode = true
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean       # Truncate the database
+    Timecop.return
+  end
+
+  config.order = "random"
+end
+