bitbot-trader 0.0.1

data/spec/support/http_request_mock.rb

@@ -0,0 +1,7 @@
+class HttpRequestMock
+  attr_reader :path, :params
+
+  def post(path, params = {})
+    {success: true, path: path, params: params}
+  end
+end

data/spec/support/provider_mock.rb

@@ -0,0 +1,5 @@
+def provider_double
+  Struct.new(:client) {
+    include ApiMethods
+  }
+end

data/spec/unit/bitbot/trader/account_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Account do
+  describe "#wallet" do
+    subject { described_class.new(wallets: wallets).wallet(currency) }
+
+    let(:wallets) {
+      [
+        {currency: "EUR", value: 123},
+        {currency: "BTC", value: 43}
+      ]
+    }
+
+    context "when EUR" do
+      let(:currency) { "EUR" }
+
+      it { should be_a(Wallet) }
+      its(:balance) { should eq(123) }
+    end
+
+    context "when BTC" do
+      let(:currency) { "BTC" }
+
+      it { should be_a(Wallet) }
+      its(:balance) { should eq(43) }
+    end
+  end
+end

data/spec/unit/bitbot/trader/api_methods_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe ApiMethods do
+  describe "#account" do
+    subject { object.account }
+
+    let(:object)        { provider_double.new(client) }
+    let(:client)        { double("client") }
+
+    let(:request_class) { Class.new }
+    let(:request)       { double("request") }
+
+    before do
+      object.class.const_set("AccountInfoRequest", request_class)
+      request_class.stub(:new).with(client) { request }
+    end
+
+    it "calls request class" do
+      request.should_receive(:call)
+      subject
+    end
+  end
+
+  describe "#open_orders" do
+    subject { object.open_orders }
+
+    let(:object)        { provider_double.new(client) }
+    let(:client)        { double("client") }
+
+    let(:request_class) { Class.new }
+    let(:request)       { double("request") }
+
+    before do
+      object.class.const_set("OpenOrdersRequest", request_class)
+      request_class.stub(:new).with(client) { request }
+    end
+
+    it "calls request class" do
+      request.should_receive(:call)
+      subject
+    end
+  end
+end

data/spec/unit/bitbot/trader/open_order_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe OpenOrder do
+  describe "ask?" do
+    subject { described_class.new(options).ask? }
+
+    context "when bid" do
+      let(:options) { {bid: true} }
+
+      it { should be(false) }
+    end
+
+    context "when ask" do
+      let(:options) { {bid: false} }
+
+      it { should be(true) }
+    end
+  end
+end

data/spec/unit/bitbot/trader/provider_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Provider do
+  describe "#client" do
+    subject { klass.new(client).client }
+
+    let(:klass) {
+      Class.new(described_class) {
+        def initialize(client)
+          @client = client
+        end
+      }
+    }
+    let(:client) { double }
+
+    it { should be(client) }
+  end
+end

data/spec/unit/bitbot/trader/providers/bitstamp/http_client_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe Providers::Bitstamp::HttpClient do
+  describe ".build" do
+    subject { described_class.build(options) }
+
+    let(:options) { {username: "double", password: "double"} }
+    let(:connection) { double }
+
+    before do
+      described_class.should_receive(:make_connection).
+        and_return(connection)
+    end
+
+    it { should be_a(described_class) }
+    its(:username) { should eq("double") }
+    its(:password) { should eq("double") }
+    its(:connection) { should be(connection) }
+  end
+
+  describe ".make_connection" do
+    subject(:connection) { described_class.make_connection }
+
+    it { should be_a(Faraday::Connection) }
+
+    it "has correct url_prefix" do
+      expect(subject.url_prefix.to_s + "/").to eq(described_class::HOST)
+    end
+
+    context "request handlers" do
+      subject { connection.builder.handlers }
+
+      it { should eq([
+        Faraday::Request::UrlEncoded,
+        Faraday::Adapter::NetHttp])
+      }
+    end
+  end
+
+  describe "#post" do
+    let(:client)     { described_class.new(connection, "username", "password") }
+    let(:connection) { double("connection") }
+    let(:path)       { "some_action" }
+
+    context "with default options" do
+      subject { client.post(path) }
+
+      let(:options) { {param: "value"} }
+
+      before do
+        connection.should_receive(:post).
+          with("some_action/", {user: "username", password: "password"}).
+          and_return(double(body: '{"result": "yey"}'))
+      end
+
+      it { should eq({"result" => "yey"}) }
+    end
+
+    context "with custom options" do
+      subject { client.post(path, options) }
+
+      let(:options) { {param: "value"} }
+
+      before do
+        connection.should_receive(:post).
+          with("some_action/", {
+            user: "username", password: "password", param: "value"
+          }).
+          and_return(double(body: '{"result": "yey"}'))
+      end
+
+      it { should eq({"result" => "yey"}) }
+    end
+  end
+end

data/spec/unit/bitbot/trader/providers/bitstamp/open_order_parser_spec.rb

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe Providers::Bitstamp::OpenOrderParser do
+  describe"#parse" do
+    subject(:open_order) { parser.parse }
+
+    let(:parser)  { described_class.new(data) }
+
+    context "when bid" do
+      let(:data) {
+        {
+          "id"       => 2826860,
+          "type"     => 0,
+          "price"    => "20.10",
+          "amount"   => "10.00000000",
+          "datetime" => "2013-04-20 12:12:14"
+        }
+      }
+
+      it { should be_a(OpenOrder) }
+      it { should be_bid }
+      its(:id) { should eq("2826860") }
+
+      context "amount" do
+        subject { open_order.amount }
+        it { should be_a(Amount) }
+        its(:value) { should eq(10) }
+        its(:currency) { should eq("BTC") }
+      end
+
+      context "price" do
+        subject { open_order.price }
+        it { should be_a(Price) }
+        its(:value) { should eq(20.1) }
+        its(:currency) { should eq("USD") }
+      end
+    end
+
+    context "when ask" do
+      let(:data) {
+        {
+          "id"       => 2851404,
+          "type"     => 1,
+          "price"    => "200.00",
+          "amount"   => "6.00000000",
+          "datetime" => "2013-04-22 17:47:43"
+        }
+      }
+
+      it { should be_a(OpenOrder) }
+      it { should be_ask }
+      its(:id) { should eq("2851404") }
+
+      context "amount" do
+        subject { open_order.amount }
+        it { should be_a(Amount) }
+        its(:value) { should eq(6) }
+        its(:currency) { should eq("BTC") }
+      end
+
+      context "price" do
+        subject { open_order.price }
+        it { should be_a(Price) }
+        its(:value) { should eq(200) }
+        its(:currency) { should eq("USD") }
+      end
+    end
+  end
+end

data/spec/unit/bitbot/trader/providers/bitstamp/open_orders_request_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Providers::Bitstamp::OpenOrdersRequest do
+  describe "#call" do
+    subject { request.call }
+
+    let(:request)  { described_class.new(client) }
+    let(:client)   { HttpRequestMock.new }
+
+    let(:raw_open_orders) { [raw_open_order] }
+    let(:raw_open_order)  { double("raw open order") }
+
+    before do
+      client.stub(:post).with("open_orders").and_return(raw_open_orders)
+    end
+
+    it "parses open orders" do
+      Providers::Bitstamp::OpenOrderParser.should_receive(:new).
+        with(raw_open_order).
+        and_return(double(parse: "result"))
+      expect(subject).to eq(["result"])
+    end
+  end
+end

data/spec/unit/bitbot/trader/providers/bitstamp_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Providers::Bitstamp do
+  describe "#initialize" do
+    let(:options)  { double("options") }
+    let(:username) { "23443" }
+    let(:password) { "TopSecret" }
+
+    context "when with custom http client" do
+      subject { described_class.new(options, http_client) }
+
+      let(:http_client) { double("HttpClient") }
+
+      it { should be_a(described_class) }
+      its(:client) { should be(http_client) }
+    end
+
+    context "when with default http client class" do
+      subject { described_class.new(options) }
+
+      before do
+        described_class::HttpClient.should_receive(:build).with(options)
+      end
+
+      it { should be_a(described_class) }
+    end
+  end
+
+  describe "#open_orders" do
+    subject { provider.open_orders }
+
+    let(:provider) { described_class.new(options, client) }
+    let(:options)  { { username: "double", password: "double" } }
+    let(:client)   { double.as_null_object }
+
+    let(:request)     { double("request", call: open_orders) }
+    let(:open_orders) { double("open orders") }
+
+    before do
+      described_class::OpenOrdersRequest.stub(:new).with(client) { request }
+    end
+
+    it { should be(open_orders) }
+  end
+end

data/spec/unit/bitbot/trader/providers/mt_gox/account_info_parser_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe Providers::MtGox::AccountInfoParser do
+  describe ".parse_wallets" do
+    subject { described_class.parse_wallets(raw_wallets) }
+
+    let(:raw_wallets) {
+      {"EUR" => {"Balance" => balance}}
+    }
+    let(:balance) { double }
+
+    it "delegates each wallet balance to ValueWithCurrency" do
+      Providers::MtGox::ValueWithCurrencyCoercer.
+        should_receive(:call).
+        with(balance)
+      subject
+    end
+  end
+
+  describe "#parse" do
+    subject(:account) { described_class.new(data).parse }
+
+    let(:data) {
+      {
+        "Wallets" => {
+          "BTC" => {
+            "Balance" => {"value_int" => "99470000", "currency" => "BTC"}
+          },
+          "EUR" => {
+            "Balance" => {"value_int" => "12314", "currency" => "EUR"},
+          },
+          "USD" => {
+            "Balance" => {"value_int" => "353302728", "currency" => "USD"},
+          },
+        },
+        "Trade_Fee" => 0.53
+      }
+    }
+
+    it { should be_a(Account) }
+    its(:fee) { should eq(0.53) }
+
+    context "btc wallet" do
+      subject { account.wallet("BTC") }
+      its(:balance) { should eq(0.9947) }
+    end
+
+    context "eur wallet" do
+      subject { account.wallet("EUR") }
+      its(:balance) { should eq(0.12314) }
+    end
+
+    context "usd wallet" do
+      subject { account.wallet("USD") }
+      its(:balance) { should eq(3533.02728) }
+    end
+  end
+end

data/spec/unit/bitbot/trader/providers/mt_gox/account_info_request_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Providers::MtGox::AccountInfoRequest do
+  describe "#call" do
+    subject { request.call }
+
+    let(:request)  { described_class.new(client) }
+    let(:client)   { HttpRequestMock.new }
+
+    let(:result)      { {"data" => raw_account} }
+    let(:raw_account) { double }
+
+    before do
+      client.stub(:post).with("money/info").and_return(result)
+    end
+
+    it "parses open orders" do
+      Providers::MtGox::AccountInfoParser.should_receive(:new).
+        with(raw_account).
+        and_return(double(parse: "result"))
+      expect(subject).to eq("result")
+    end
+  end
+end

data/spec/unit/bitbot/trader/providers/mt_gox/http_client/hmac_middleware_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Providers::MtGox::HttpClient::HmacMiddleware do
+  describe ".extract_params" do
+    subject { described_class.extract_params(env) }
+
+    let(:env) { {request_headers: headers, url: url, body: body} }
+
+    let(:headers) { {} }
+    let(:url)     { double(to_s: "https://data.mtgox.com/api/2/money/orders") }
+    let(:body)    { {} }
+
+    its([0]) { should eql(headers) }
+    its([1]) { should eq("money/orders") }
+    its([2]) { should eql(body) }
+  end
+
+  describe "#call" do
+    subject { described_class.new(app, options).call(env) }
+
+    let(:app)     { double }
+    let(:options) { {key: "KEY", secret: "c2VjcmV0" } }
+    let(:env)     { double }
+
+    let(:headers) { {} }
+    let(:path)    { "money/orders" }
+    let(:body)    { "nonce=123" }
+
+    before do
+      described_class.stub(:extract_params).with(env).
+        and_return([headers, path, body])
+      app.stub(:call)
+    end
+
+    it "forwards environment to app" do
+      app.should_receive(:call).with(env)
+      subject
+    end
+
+    it "adds Rest-Key to headers" do
+      subject
+      expect(headers["Rest-Key"]).to eq("KEY")
+    end
+
+    it "adds Rest-Sign to headers" do
+      subject
+      expect(headers["Rest-Sign"]).to eq("Jd1OnkDAy0mkSCq1+w3Aiyeotw+lGF0GOR3tp5Ch1DMkyRW9QJ4FrmyFZIoee5itfAOnq9sRslqPd3n3UKw64A==")
+    end
+
+    it "adds User-Agent to headers" do
+      subject
+      expect(headers["User-Agent"]).to eq("bitbot-trader")
+    end
+  end
+end