tastytrade 0.2.0 → 0.3.1

data/spec/tastytrade/models/account_order_history_spec.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Tastytrade::Models::Account#get_order_history" do
+  let(:session) { instance_double(Tastytrade::Session) }
+  let(:account_number) { "5WZ38925" }
+  let(:account) { Tastytrade::Models::Account.new("account-number" => account_number) }
+
+  let(:order_history_response) do
+    {
+      "data" => {
+        "items" => [
+          {
+            "id" => "12345",
+            "account-number" => account_number,
+            "status" => "Filled",
+            "cancellable" => false,
+            "editable" => false,
+            "time-in-force" => "Day",
+            "order-type" => "Limit",
+            "underlying-symbol" => "AAPL",
+            "price" => "150.00",
+            "created-at" => "2024-01-01T10:00:00Z",
+            "filled-at" => "2024-01-01T10:05:00Z",
+            "legs" => [
+              {
+                "symbol" => "AAPL",
+                "instrument-type" => "Equity",
+                "action" => "Buy to Open",
+                "quantity" => 100,
+                "remaining-quantity" => 0
+              }
+            ]
+          },
+          {
+            "id" => "12346",
+            "account-number" => account_number,
+            "status" => "Cancelled",
+            "cancellable" => false,
+            "editable" => false,
+            "time-in-force" => "Day",
+            "order-type" => "Market",
+            "underlying-symbol" => "MSFT",
+            "created-at" => "2024-01-02T14:30:00Z",
+            "cancelled-at" => "2024-01-02T14:35:00Z",
+            "legs" => [
+              {
+                "symbol" => "MSFT",
+                "instrument-type" => "Equity",
+                "action" => "Sell to Close",
+                "quantity" => 50,
+                "remaining-quantity" => 50
+              }
+            ]
+          }
+        ]
+      }
+    }
+  end
+
+  context "without filters" do
+    it "retrieves all historical orders" do
+      expect(session).to receive(:get)
+        .with("/accounts/#{account_number}/orders/", {})
+        .and_return(order_history_response)
+
+      orders = account.get_order_history(session)
+
+      expect(orders).to be_an(Array)
+      expect(orders.size).to eq(2)
+      expect(orders.first).to be_a(Tastytrade::Models::LiveOrder)
+      expect(orders.first.id).to eq("12345")
+      expect(orders.first.status).to eq("Filled")
+      expect(orders.last.id).to eq("12346")
+      expect(orders.last.status).to eq("Cancelled")
+    end
+  end
+
+  context "with status filter" do
+    it "includes status in request params" do
+      expect(session).to receive(:get)
+        .with("/accounts/#{account_number}/orders/", { "status" => "Filled" })
+        .and_return(order_history_response)
+
+      account.get_order_history(session, status: "Filled")
+    end
+
+    it "ignores invalid status values" do
+      expect(session).to receive(:get)
+        .with("/accounts/#{account_number}/orders/", {})
+        .and_return(order_history_response)
+
+      account.get_order_history(session, status: "InvalidStatus")
+    end
+  end
+
+  context "with underlying symbol filter" do
+    it "includes underlying symbol in request params" do
+      expect(session).to receive(:get)
+        .with("/accounts/#{account_number}/orders/", { "underlying-symbol" => "AAPL" })
+        .and_return(order_history_response)
+
+      account.get_order_history(session, underlying_symbol: "AAPL")
+    end
+  end
+
+  context "with time filters" do
+    it "includes time range in request params" do
+      from_time = Time.parse("2024-01-01T00:00:00Z")
+      to_time = Time.parse("2024-01-31T23:59:59Z")
+
+      expect(session).to receive(:get)
+        .with("/accounts/#{account_number}/orders/", {
+                "from-time" => from_time.iso8601,
+                "to-time" => to_time.iso8601
+              })
+        .and_return(order_history_response)
+
+      account.get_order_history(session, from_time: from_time, to_time: to_time)
+    end
+  end
+
+  context "with pagination" do
+    it "includes pagination parameters" do
+      expect(session).to receive(:get)
+        .with("/accounts/#{account_number}/orders/", {
+                "page-offset" => 100,
+                "page-limit" => 50
+              })
+        .and_return(order_history_response)
+
+      account.get_order_history(session, page_offset: 100, page_limit: 50)
+    end
+  end
+
+  context "with multiple filters" do
+    it "combines all filters in request" do
+      from_time = Time.parse("2024-01-01T00:00:00Z")
+      to_time = Time.parse("2024-01-31T23:59:59Z")
+
+      expect(session).to receive(:get)
+        .with("/accounts/#{account_number}/orders/", {
+                "status" => "Filled",
+                "underlying-symbol" => "AAPL",
+                "from-time" => from_time.iso8601,
+                "to-time" => to_time.iso8601,
+                "page-limit" => 100
+              })
+        .and_return(order_history_response)
+
+      account.get_order_history(
+        session,
+        status: "Filled",
+        underlying_symbol: "AAPL",
+        from_time: from_time,
+        to_time: to_time,
+        page_limit: 100
+      )
+    end
+  end
+end
+
+RSpec.describe "Tastytrade::Models::Account#get_order" do
+  let(:session) { instance_double(Tastytrade::Session) }
+  let(:account_number) { "5WZ38925" }
+  let(:account) { Tastytrade::Models::Account.new("account-number" => account_number) }
+  let(:order_id) { "12345" }
+
+  let(:order_response) do
+    {
+      "data" => {
+        "id" => order_id,
+        "account-number" => account_number,
+        "status" => "Live",
+        "cancellable" => true,
+        "editable" => true,
+        "time-in-force" => "GTC",
+        "order-type" => "Limit",
+        "underlying-symbol" => "AAPL",
+        "price" => "150.00",
+        "created-at" => "2024-01-01T10:00:00Z",
+        "legs" => [
+          {
+            "symbol" => "AAPL",
+            "instrument-type" => "Equity",
+            "action" => "Buy to Open",
+            "quantity" => 100,
+            "remaining-quantity" => 100
+          }
+        ]
+      }
+    }
+  end
+
+  it "retrieves a specific order by ID" do
+    expect(session).to receive(:get)
+      .with("/accounts/#{account_number}/orders/#{order_id}/")
+      .and_return(order_response)
+
+    order = account.get_order(session, order_id)
+
+    expect(order).to be_a(Tastytrade::Models::LiveOrder)
+    expect(order.id).to eq(order_id)
+    expect(order.status).to eq("Live")
+    expect(order.underlying_symbol).to eq("AAPL")
+    expect(order.cancellable?).to be true
+    expect(order.editable?).to be true
+  end
+
+  context "when order doesn't exist" do
+    it "raises an error" do
+      error_response = {
+        "error" => {
+          "code" => "order_not_found",
+          "message" => "Order not found"
+        }
+      }
+
+      expect(session).to receive(:get)
+        .with("/accounts/#{account_number}/orders/#{order_id}/")
+        .and_raise(Tastytrade::Error.new("Order not found"))
+
+      expect {
+        account.get_order(session, order_id)
+      }.to raise_error(Tastytrade::Error, "Order not found")
+    end
+  end
+end

data/spec/tastytrade/models/account_order_management_spec.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Tastytrade::Models::Account, "#get_live_orders" do
+  let(:session) { instance_double(Tastytrade::Session) }
+  let(:account) { described_class.new({ "account-number" => "5WV12345" }) }
+
+  let(:live_orders_response) do
+    {
+      "data" => {
+        "items" => [
+          {
+            "id" => "12345",
+            "account-number" => "5WV12345",
+            "status" => "Live",
+            "cancellable" => true,
+            "editable" => true,
+            "time-in-force" => "Day",
+            "order-type" => "Limit",
+            "price" => "150.50",
+            "underlying-symbol" => "AAPL",
+            "legs" => [
+              {
+                "symbol" => "AAPL",
+                "action" => "Buy",
+                "quantity" => 100,
+                "remaining-quantity" => 100
+              }
+            ]
+          },
+          {
+            "id" => "12346",
+            "account-number" => "5WV12345",
+            "status" => "Filled",
+            "cancellable" => false,
+            "editable" => false,
+            "time-in-force" => "Day",
+            "order-type" => "Market",
+            "underlying-symbol" => "TSLA",
+            "filled-at" => "2024-01-15T09:35:00.000Z",
+            "legs" => [
+              {
+                "symbol" => "TSLA",
+                "action" => "Sell",
+                "quantity" => 50,
+                "remaining-quantity" => 0
+              }
+            ]
+          }
+        ]
+      }
+    }
+  end
+
+  describe "without filters" do
+    it "retrieves all live orders" do
+      allow(session).to receive(:get)
+        .with("/accounts/5WV12345/orders/live/", {})
+        .and_return(live_orders_response)
+
+      orders = account.get_live_orders(session)
+
+      expect(orders).to be_an(Array)
+      expect(orders.size).to eq(2)
+      expect(orders.first).to be_a(Tastytrade::Models::LiveOrder)
+      expect(orders.first.id).to eq("12345")
+      expect(orders.first.status).to eq("Live")
+      expect(orders.last.status).to eq("Filled")
+    end
+  end
+
+  describe "with status filter" do
+    it "includes status in request params" do
+      expect(session).to receive(:get)
+        .with("/accounts/5WV12345/orders/live/", { "status" => "Live" })
+        .and_return({ "data" => { "items" => [] } })
+
+      account.get_live_orders(session, status: "Live")
+    end
+
+    it "ignores invalid status values" do
+      expect(session).to receive(:get)
+        .with("/accounts/5WV12345/orders/live/", {})
+        .and_return({ "data" => { "items" => [] } })
+
+      account.get_live_orders(session, status: "InvalidStatus")
+    end
+  end
+
+  describe "with underlying symbol filter" do
+    it "includes underlying symbol in request params" do
+      expect(session).to receive(:get)
+        .with("/accounts/5WV12345/orders/live/", { "underlying-symbol" => "AAPL" })
+        .and_return({ "data" => { "items" => [] } })
+
+      account.get_live_orders(session, underlying_symbol: "AAPL")
+    end
+  end
+
+  describe "with time filters" do
+    let(:from_time) { Time.parse("2024-01-15T09:00:00Z") }
+    let(:to_time) { Time.parse("2024-01-15T17:00:00Z") }
+
+    it "includes time range in request params" do
+      expect(session).to receive(:get)
+        .with("/accounts/5WV12345/orders/live/",
+              {
+                "from-time" => from_time.iso8601,
+                "to-time" => to_time.iso8601
+              })
+        .and_return({ "data" => { "items" => [] } })
+
+      account.get_live_orders(session, from_time: from_time, to_time: to_time)
+    end
+  end
+end
+
+RSpec.describe Tastytrade::Models::Account, "#cancel_order" do
+  let(:session) { instance_double(Tastytrade::Session) }
+  let(:account) { described_class.new({ "account-number" => "5WV12345" }) }
+  let(:order_id) { "12345" }
+
+  describe "successful cancellation" do
+    it "sends DELETE request and returns nil" do
+      expect(session).to receive(:delete)
+        .with("/accounts/5WV12345/orders/12345/")
+        .and_return(nil)
+
+      result = account.cancel_order(session, order_id)
+      expect(result).to be_nil
+    end
+  end
+
+  describe "error handling" do
+    context "when order is already filled" do
+      it "raises OrderAlreadyFilledError" do
+        error = Tastytrade::Error.new("Order already filled")
+        expect(session).to receive(:delete)
+          .with("/accounts/5WV12345/orders/12345/")
+          .and_raise(error)
+
+        expect do
+          account.cancel_order(session, order_id)
+        end.to raise_error(Tastytrade::OrderAlreadyFilledError, /already been filled/)
+      end
+    end
+
+    context "when order is not cancellable" do
+      it "raises OrderNotCancellableError" do
+        error = Tastytrade::Error.new("Cannot cancel order in current state")
+        expect(session).to receive(:delete)
+          .with("/accounts/5WV12345/orders/12345/")
+          .and_raise(error)
+
+        expect do
+          account.cancel_order(session, order_id)
+        end.to raise_error(Tastytrade::OrderNotCancellableError, /not in a cancellable state/)
+      end
+    end
+
+    context "when other error occurs" do
+      it "re-raises the original error" do
+        error = Tastytrade::Error.new("Network error")
+        expect(session).to receive(:delete)
+          .with("/accounts/5WV12345/orders/12345/")
+          .and_raise(error)
+
+        expect do
+          account.cancel_order(session, order_id)
+        end.to raise_error(Tastytrade::Error, "Network error")
+      end
+    end
+  end
+end
+
+RSpec.describe Tastytrade::Models::Account, "#replace_order" do
+  let(:session) { instance_double(Tastytrade::Session) }
+  let(:account) { described_class.new({ "account-number" => "5WV12345" }) }
+  let(:order_id) { "12345" }
+  let(:new_order) { instance_double(Tastytrade::Order) }
+  let(:order_params) do
+    {
+      "time-in-force" => "Day",
+      "order-type" => "Limit",
+      "price" => "155.00",
+      "legs" => [
+        {
+          "action" => "Buy",
+          "symbol" => "AAPL",
+          "quantity" => 50
+        }
+      ]
+    }
+  end
+
+  let(:replace_response) do
+    {
+      "data" => {
+        "id" => "12347",
+        "account-number" => "5WV12345",
+        "status" => "Received",
+        "cancellable" => true,
+        "editable" => true,
+        "time-in-force" => "Day",
+        "order-type" => "Limit",
+        "price" => "155.00"
+      }
+    }
+  end
+
+  describe "successful replacement" do
+    it "sends PUT request and returns OrderResponse" do
+      expect(new_order).to receive(:to_api_params).and_return(order_params)
+      expect(session).to receive(:put)
+        .with("/accounts/5WV12345/orders/12345/", order_params)
+        .and_return(replace_response)
+
+      result = account.replace_order(session, order_id, new_order)
+
+      expect(result).to be_a(Tastytrade::Models::OrderResponse)
+      expect(result.order_id).to eq("12347")
+      expect(result.status).to eq("Received")
+    end
+  end
+
+  describe "error handling" do
+    before do
+      allow(new_order).to receive(:to_api_params).and_return(order_params)
+    end
+
+    context "when order is not editable" do
+      it "raises OrderNotEditableError" do
+        error = Tastytrade::Error.new("Order not editable in current state")
+        expect(session).to receive(:put)
+          .with("/accounts/5WV12345/orders/12345/", order_params)
+          .and_raise(error)
+
+        expect do
+          account.replace_order(session, order_id, new_order)
+        end.to raise_error(Tastytrade::OrderNotEditableError, /not in an editable state/)
+      end
+    end
+
+    context "when quantity exceeds remaining" do
+      it "raises InsufficientQuantityError" do
+        error = Tastytrade::Error.new("Quantity exceeds remaining amount")
+        expect(session).to receive(:put)
+          .with("/accounts/5WV12345/orders/12345/", order_params)
+          .and_raise(error)
+
+        expect do
+          account.replace_order(session, order_id, new_order)
+        end.to raise_error(Tastytrade::InsufficientQuantityError, /exceeding remaining amount/)
+      end
+    end
+
+    context "when other error occurs" do
+      it "re-raises the original error" do
+        error = Tastytrade::Error.new("Server error")
+        expect(session).to receive(:put)
+          .with("/accounts/5WV12345/orders/12345/", order_params)
+          .and_raise(error)
+
+        expect do
+          account.replace_order(session, order_id, new_order)
+        end.to raise_error(Tastytrade::Error, "Server error")
+      end
+    end
+  end
+end

data/spec/tastytrade/models/account_place_order_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+RSpec.describe "Tastytrade::Models::Account#place_order" do
+  let(:session) { instance_double(Tastytrade::Session) }
+  let(:account) { Tastytrade::Models::Account.new("account-number" => "5WX12345") }
+
+  let(:order_leg) do
+    Tastytrade::OrderLeg.new(
+      action: Tastytrade::OrderAction::BUY_TO_OPEN,
+      symbol: "AAPL",
+      quantity: 100
+    )
+  end
+
+  let(:market_order) do
+    Tastytrade::Order.new(
+      type: Tastytrade::OrderType::MARKET,
+      legs: order_leg
+    )
+  end
+
+  let(:limit_order) do
+    Tastytrade::Order.new(
+      type: Tastytrade::OrderType::LIMIT,
+      legs: order_leg,
+      price: 150.50
+    )
+  end
+
+  let(:successful_response) do
+    {
+      "data" => {
+        "id" => "123456",
+        "account-number" => "5WX12345",
+        "status" => "Routed",
+        "buying-power-effect" => "-15050.00"
+      }
+    }
+  end
+
+  let(:dry_run_response) do
+    {
+      "data" => {
+        "buying-power-effect" => {
+          "impact" => "1.50",
+          "change-in-buying-power" => "1.50"
+        },
+        "warnings" => [
+          { "code" => "market_closed", "message" => "Market is closed" }
+        ]
+      }
+    }
+  end
+
+  describe "successful order placement" do
+    before do
+      allow(session).to receive(:post).and_return(successful_response)
+    end
+
+    it "places a market order" do
+      response = account.place_order(session, market_order, skip_validation: true)
+
+      expect(session).to have_received(:post).with(
+        "/accounts/5WX12345/orders",
+        market_order.to_api_params
+      )
+
+      expect(response).to be_a(Tastytrade::Models::OrderResponse)
+      expect(response.order_id).to eq("123456")
+      expect(response.status).to eq("Routed")
+    end
+
+    it "places a limit order with correct parameters" do
+      response = account.place_order(session, limit_order, skip_validation: true)
+
+      expect(session).to have_received(:post).with(
+        "/accounts/5WX12345/orders",
+        hash_including(
+          "order-type" => "Limit",
+          "price" => "150.5",
+          "price-effect" => "Debit"
+        )
+      )
+
+      expect(response).to be_a(Tastytrade::Models::OrderResponse)
+    end
+
+    it "handles dry run orders" do
+      allow(session).to receive(:post).and_return(dry_run_response)
+
+      response = account.place_order(session, market_order, dry_run: true)
+
+      expect(session).to have_received(:post).with(
+        "/accounts/5WX12345/orders/dry-run",
+        anything
+      )
+
+      expect(response.buying_power_effect).to be_a(Tastytrade::Models::BuyingPowerEffect)
+      expect(response.buying_power_effect.impact).to eq(BigDecimal("1.50"))
+      expect(response.warnings).not_to be_empty
+    end
+  end
+
+  describe "error handling" do
+    it "handles API errors" do
+      allow(session).to receive(:post).and_raise(
+        Tastytrade::Error, "Invalid symbol"
+      )
+
+      expect {
+        account.place_order(session, market_order, skip_validation: true)
+      }.to raise_error(Tastytrade::Error, "Invalid symbol")
+    end
+
+    it "handles network timeouts" do
+      allow(session).to receive(:post).and_raise(
+        Tastytrade::NetworkTimeoutError, "Request timed out"
+      )
+
+      expect {
+        account.place_order(session, market_order, skip_validation: true)
+      }.to raise_error(Tastytrade::NetworkTimeoutError)
+    end
+  end
+end