tastytrade 0.2.0 → 0.3.0

data/spec/tastytrade/models/trading_status_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Tastytrade::Models::TradingStatus do
+  let(:trading_status_data) do
+    {
+      "account-number" => "5WT0001",
+      "equities-margin-calculation-type" => "REG_T",
+      "fee-schedule-name" => "standard",
+      "futures-margin-rate-multiplier" => "1.0",
+      "has-intraday-equities-margin" => false,
+      "id" => 123456,
+      "is-aggregated-at-clearing" => false,
+      "is-closed" => false,
+      "is-closing-only" => false,
+      "is-cryptocurrency-enabled" => true,
+      "is-frozen" => false,
+      "is-full-equity-margin-required" => false,
+      "is-futures-closing-only" => false,
+      "is-futures-intra-day-enabled" => true,
+      "is-futures-enabled" => true,
+      "is-in-day-trade-equity-maintenance-call" => false,
+      "is-in-margin-call" => false,
+      "is-pattern-day-trader" => false,
+      "is-small-notional-futures-intra-day-enabled" => false,
+      "is-roll-the-day-forward-enabled" => true,
+      "are-far-otm-net-options-restricted" => false,
+      "options-level" => "Level 2",
+      "short-calls-enabled" => false,
+      "small-notional-futures-margin-rate-multiplier" => "1.0",
+      "is-equity-offering-enabled" => true,
+      "is-equity-offering-closing-only" => false,
+      "updated-at" => "2024-01-15T10:30:00Z",
+      "is-portfolio-margin-enabled" => false,
+      "is-risk-reducing-only" => nil,
+      "day-trade-count" => 0,
+      "autotrade-account-type" => nil,
+      "clearing-account-number" => nil,
+      "clearing-aggregation-identifier" => nil,
+      "is-cryptocurrency-closing-only" => false,
+      "pdt-reset-on" => nil,
+      "cmta-override" => nil,
+      "enhanced-fraud-safeguards-enabled-at" => nil
+    }
+  end
+
+  subject(:trading_status) { described_class.new(trading_status_data) }
+
+  describe "#initialize" do
+    it "parses all required fields correctly" do
+      expect(trading_status.account_number).to eq("5WT0001")
+      expect(trading_status.equities_margin_calculation_type).to eq("REG_T")
+      expect(trading_status.fee_schedule_name).to eq("standard")
+      expect(trading_status.futures_margin_rate_multiplier).to eq(BigDecimal("1.0"))
+      expect(trading_status.has_intraday_equities_margin).to eq(false)
+      expect(trading_status.id).to eq(123456)
+      expect(trading_status.is_aggregated_at_clearing).to eq(false)
+      expect(trading_status.is_closed).to eq(false)
+      expect(trading_status.is_closing_only).to eq(false)
+      expect(trading_status.is_cryptocurrency_enabled).to eq(true)
+      expect(trading_status.is_frozen).to eq(false)
+      expect(trading_status.is_full_equity_margin_required).to eq(false)
+      expect(trading_status.is_futures_closing_only).to eq(false)
+      expect(trading_status.is_futures_intra_day_enabled).to eq(true)
+      expect(trading_status.is_futures_enabled).to eq(true)
+      expect(trading_status.is_in_day_trade_equity_maintenance_call).to eq(false)
+      expect(trading_status.is_in_margin_call).to eq(false)
+      expect(trading_status.is_pattern_day_trader).to eq(false)
+      expect(trading_status.options_level).to eq("Level 2")
+      expect(trading_status.short_calls_enabled).to eq(false)
+      expect(trading_status.updated_at).to be_a(Time)
+    end
+
+    it "parses optional fields correctly" do
+      expect(trading_status.is_portfolio_margin_enabled).to eq(false)
+      expect(trading_status.is_risk_reducing_only).to be_nil
+      expect(trading_status.day_trade_count).to eq(0)
+      expect(trading_status.is_cryptocurrency_closing_only).to eq(false)
+    end
+
+    context "with PDT reset date" do
+      let(:trading_status_data_with_pdt) do
+        trading_status_data.merge("pdt-reset-on" => "2024-02-15")
+      end
+
+      subject(:trading_status_with_pdt) { described_class.new(trading_status_data_with_pdt) }
+
+      it "parses the PDT reset date correctly" do
+        expect(trading_status_with_pdt.pdt_reset_on).to be_a(Date)
+        expect(trading_status_with_pdt.pdt_reset_on.to_s).to eq("2024-02-15")
+      end
+    end
+  end
+
+  describe "#can_trade_options?" do
+    context "when options are enabled" do
+      it "returns true" do
+        expect(trading_status.can_trade_options?).to eq(true)
+      end
+    end
+
+    context "when options level is 'No Permissions'" do
+      before { trading_status_data["options-level"] = "No Permissions" }
+
+      it "returns false" do
+        expect(trading_status.can_trade_options?).to eq(false)
+      end
+    end
+
+    context "when options level is nil" do
+      before { trading_status_data["options-level"] = nil }
+
+      it "returns false" do
+        expect(trading_status.can_trade_options?).to eq(false)
+      end
+    end
+  end
+
+  describe "#can_trade_futures?" do
+    context "when futures are enabled and not closing only" do
+      it "returns true" do
+        expect(trading_status.can_trade_futures?).to eq(true)
+      end
+    end
+
+    context "when futures are disabled" do
+      before { trading_status_data["is-futures-enabled"] = false }
+
+      it "returns false" do
+        expect(trading_status.can_trade_futures?).to eq(false)
+      end
+    end
+
+    context "when futures are closing only" do
+      before { trading_status_data["is-futures-closing-only"] = true }
+
+      it "returns false" do
+        expect(trading_status.can_trade_futures?).to eq(false)
+      end
+    end
+  end
+
+  describe "#can_trade_cryptocurrency?" do
+    context "when crypto is enabled and not closing only" do
+      it "returns true" do
+        expect(trading_status.can_trade_cryptocurrency?).to eq(true)
+      end
+    end
+
+    context "when crypto is disabled" do
+      before { trading_status_data["is-cryptocurrency-enabled"] = false }
+
+      it "returns false" do
+        expect(trading_status.can_trade_cryptocurrency?).to eq(false)
+      end
+    end
+
+    context "when crypto is closing only" do
+      before { trading_status_data["is-cryptocurrency-closing-only"] = true }
+
+      it "returns false" do
+        expect(trading_status.can_trade_cryptocurrency?).to eq(false)
+      end
+    end
+  end
+
+  describe "#restricted?" do
+    context "when account has no restrictions" do
+      it "returns false" do
+        expect(trading_status.restricted?).to eq(false)
+      end
+    end
+
+    context "when account is closed" do
+      before { trading_status_data["is-closed"] = true }
+
+      it "returns true" do
+        expect(trading_status.restricted?).to eq(true)
+      end
+    end
+
+    context "when account is frozen" do
+      before { trading_status_data["is-frozen"] = true }
+
+      it "returns true" do
+        expect(trading_status.restricted?).to eq(true)
+      end
+    end
+
+    context "when account is in margin call" do
+      before { trading_status_data["is-in-margin-call"] = true }
+
+      it "returns true" do
+        expect(trading_status.restricted?).to eq(true)
+      end
+    end
+
+    context "when account is risk reducing only" do
+      before { trading_status_data["is-risk-reducing-only"] = true }
+
+      it "returns true" do
+        expect(trading_status.restricted?).to eq(true)
+      end
+    end
+  end
+
+  describe "#active_restrictions" do
+    context "when account has no restrictions" do
+      it "returns an empty array" do
+        expect(trading_status.active_restrictions).to eq([])
+      end
+    end
+
+    context "when account has multiple restrictions" do
+      before do
+        trading_status_data["is-in-margin-call"] = true
+        trading_status_data["is-pattern-day-trader"] = true
+        trading_status_data["is-futures-closing-only"] = true
+      end
+
+      it "returns all active restrictions" do
+        restrictions = trading_status.active_restrictions
+        expect(restrictions).to include("Margin Call")
+        expect(restrictions).to include("Pattern Day Trader")
+        expect(restrictions).to include("Futures Closing Only")
+      end
+    end
+  end
+
+  describe "#permissions_summary" do
+    it "returns a summary of all trading permissions" do
+      summary = trading_status.permissions_summary
+      expect(summary[:options]).to eq("Level 2")
+      expect(summary[:futures]).to eq("Enabled")
+      expect(summary[:cryptocurrency]).to eq("Enabled")
+      expect(summary[:short_calls]).to eq("Disabled")
+      expect(summary[:pattern_day_trader]).to eq("No")
+      expect(summary[:portfolio_margin]).to eq("Disabled")
+    end
+
+    context "when futures are closing only" do
+      before { trading_status_data["is-futures-closing-only"] = true }
+
+      it "shows futures as closing only" do
+        summary = trading_status.permissions_summary
+        expect(summary[:futures]).to eq("Closing Only")
+      end
+    end
+
+    context "when pattern day trader is flagged" do
+      before { trading_status_data["is-pattern-day-trader"] = true }
+
+      it "shows PDT as Yes" do
+        summary = trading_status.permissions_summary
+        expect(summary[:pattern_day_trader]).to eq("Yes")
+      end
+    end
+  end
+end

data/spec/tastytrade/models/transaction_spec.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Tastytrade::Models::Transaction do
+  let(:session) { instance_double(Tastytrade::Session) }
+  let(:account_number) { "123456" }
+
+  let(:transaction_data) do
+    {
+      "id" => 252640963,
+      "account-number" => "5WT0001",
+      "symbol" => "AAPL",
+      "instrument-type" => "Equity",
+      "underlying-symbol" => "AAPL",
+      "transaction-type" => "Trade",
+      "transaction-sub-type" => "Buy",
+      "description" => "Bought 100 AAPL @ 150.00",
+      "action" => "Buy to Open",
+      "quantity" => "100",
+      "price" => "150.00",
+      "executed-at" => "2023-07-28T21:00:00.000+00:00",
+      "transaction-date" => "2023-07-28",
+      "value" => "-15000.00",
+      "value-effect" => "Debit",
+      "net-value" => "-15007.00",
+      "net-value-effect" => "Debit",
+      "is-estimated-fee" => false,
+      "commission" => "5.00",
+      "clearing-fees" => "1.00",
+      "regulatory-fees" => "0.50",
+      "proprietary-index-option-fees" => "0.50",
+      "order-id" => "12345",
+      "value-date" => "2023-07-30",
+      "reverses-id" => nil,
+      "is-verified" => true
+    }
+  end
+
+  describe ".get_all" do
+    let(:response_data) do
+      {
+        "data" => {
+          "items" => [transaction_data]
+        }
+      }
+    end
+
+    it "fetches transactions without filters" do
+      # First call returns data
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", {})
+        .and_return(response_data)
+      # Second call returns empty to stop pagination
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", { "page-offset" => 1 })
+        .and_return({ "data" => { "items" => [] } })
+
+      transactions = described_class.get_all(session, account_number)
+
+      expect(transactions).to be_an(Array)
+      expect(transactions.length).to eq(1)
+      expect(transactions.first).to be_a(described_class)
+    end
+
+    it "applies date filters" do
+      start_date = Date.new(2023, 7, 1)
+      end_date = Date.new(2023, 7, 31)
+
+      expected_params = {
+        "start-date" => "2023-07-01",
+        "end-date" => "2023-07-31"
+      }
+
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", expected_params)
+        .and_return(response_data)
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", expected_params.merge("page-offset" => 1))
+        .and_return({ "data" => { "items" => [] } })
+
+      transactions = described_class.get_all(session, account_number,
+                                             start_date: start_date,
+                                             end_date: end_date)
+
+      expect(transactions.length).to eq(1)
+    end
+
+    it "applies symbol and instrument type filters" do
+      expected_params = {
+        "symbol" => "AAPL",
+        "instrument-type" => "Equity"
+      }
+
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", expected_params)
+        .and_return(response_data)
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", expected_params.merge("page-offset" => 1))
+        .and_return({ "data" => { "items" => [] } })
+
+      transactions = described_class.get_all(session, account_number,
+                                             symbol: "AAPL",
+                                             instrument_type: "Equity")
+
+      expect(transactions.length).to eq(1)
+    end
+
+    it "handles pagination automatically" do
+      page1_response = {
+        "data" => {
+          "items" => [transaction_data]
+        }
+      }
+
+      page2_response = {
+        "data" => {
+          "items" => [transaction_data.merge("id" => 252640964)]
+        }
+      }
+
+      page3_response = {
+        "data" => {
+          "items" => []
+        }
+      }
+
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", {})
+        .and_return(page1_response)
+
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", { "page-offset" => 1 })
+        .and_return(page2_response)
+
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", { "page-offset" => 2 })
+        .and_return(page3_response)
+
+      transactions = described_class.get_all(session, account_number)
+
+      expect(transactions.length).to eq(2)
+    end
+
+    it "respects manual pagination settings" do
+      expected_params = {
+        "per-page" => 50,
+        "page-offset" => 2
+      }
+
+      allow(session).to receive(:get)
+        .with("/accounts/#{account_number}/transactions", expected_params)
+        .and_return(response_data)
+
+      transactions = described_class.get_all(session, account_number,
+                                             per_page: 50,
+                                             page_offset: 2)
+
+      expect(transactions.length).to eq(1)
+    end
+  end
+
+  describe "attribute parsing" do
+    let(:transaction) { described_class.new(transaction_data) }
+
+    it "parses basic attributes correctly" do
+      expect(transaction.id).to eq(252640963)
+      expect(transaction.account_number).to eq("5WT0001")
+      expect(transaction.symbol).to eq("AAPL")
+      expect(transaction.instrument_type).to eq("Equity")
+      expect(transaction.underlying_symbol).to eq("AAPL")
+    end
+
+    it "parses transaction type attributes" do
+      expect(transaction.transaction_type).to eq("Trade")
+      expect(transaction.transaction_sub_type).to eq("Buy")
+      expect(transaction.description).to eq("Bought 100 AAPL @ 150.00")
+      expect(transaction.action).to eq("Buy to Open")
+    end
+
+    it "parses decimal values correctly" do
+      expect(transaction.quantity).to be_a(BigDecimal)
+      expect(transaction.quantity).to eq(BigDecimal("100"))
+      expect(transaction.price).to eq(BigDecimal("150.00"))
+      expect(transaction.value).to eq(BigDecimal("-15000.00"))
+      expect(transaction.net_value).to eq(BigDecimal("-15007.00"))
+    end
+
+    it "parses fee attributes" do
+      expect(transaction.commission).to eq(BigDecimal("5.00"))
+      expect(transaction.clearing_fees).to eq(BigDecimal("1.00"))
+      expect(transaction.regulatory_fees).to eq(BigDecimal("0.50"))
+      expect(transaction.proprietary_index_option_fees).to eq(BigDecimal("0.50"))
+    end
+
+    it "parses date and time attributes" do
+      expect(transaction.executed_at).to be_a(Time)
+      expect(transaction.executed_at.year).to eq(2023)
+      expect(transaction.transaction_date).to be_a(Date)
+      expect(transaction.transaction_date.day).to eq(28)
+    end
+
+    it "parses boolean and other attributes" do
+      expect(transaction.is_estimated_fee).to eq(false)
+      expect(transaction.is_verified).to eq(true)
+      expect(transaction.order_id).to eq("12345")
+      expect(transaction.reverses_id).to be_nil
+    end
+
+    it "handles nil decimal values" do
+      data_with_nil = transaction_data.merge("commission" => nil)
+      transaction = described_class.new(data_with_nil)
+      expect(transaction.commission).to be_nil
+    end
+
+    it "handles empty string decimal values" do
+      data_with_empty = transaction_data.merge("clearing-fees" => "")
+      transaction = described_class.new(data_with_empty)
+      expect(transaction.clearing_fees).to be_nil
+    end
+  end
+
+  describe "constants" do
+    it "defines transaction types" do
+      expect(described_class::TRANSACTION_TYPES).to include("Dividend")
+      expect(described_class::TRANSACTION_TYPES).to include("Fee")
+      expect(described_class::TRANSACTION_TYPES).to include("Deposit")
+    end
+
+    it "defines instrument types" do
+      expect(described_class::INSTRUMENT_TYPES).to include("Equity")
+      expect(described_class::INSTRUMENT_TYPES).to include("Equity Option")
+      expect(described_class::INSTRUMENT_TYPES).to include("Future")
+    end
+  end
+end

data/spec/tastytrade/order_edge_cases_spec.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+RSpec.describe "Order edge cases and additional coverage" do
+  describe Tastytrade::Order do
+    describe "edge cases" do
+      it "accepts multiple legs" do
+        leg1 = Tastytrade::OrderLeg.new(
+          action: Tastytrade::OrderAction::BUY_TO_OPEN,
+          symbol: "AAPL",
+          quantity: 100
+        )
+
+        leg2 = Tastytrade::OrderLeg.new(
+          action: Tastytrade::OrderAction::BUY_TO_OPEN,
+          symbol: "MSFT",
+          quantity: 50
+        )
+
+        order = Tastytrade::Order.new(
+          type: Tastytrade::OrderType::MARKET,
+          legs: [leg1, leg2]
+        )
+
+        expect(order.legs).to eq([leg1, leg2])
+        params = order.to_api_params
+        expect(params["legs"]).to have_attributes(size: 2)
+      end
+
+      it "handles GTC time in force" do
+        leg = Tastytrade::OrderLeg.new(
+          action: Tastytrade::OrderAction::BUY_TO_OPEN,
+          symbol: "AAPL",
+          quantity: 100
+        )
+
+        order = Tastytrade::Order.new(
+          type: Tastytrade::OrderType::LIMIT,
+          time_in_force: Tastytrade::OrderTimeInForce::GTC,
+          legs: leg,
+          price: 150
+        )
+
+        expect(order.time_in_force).to eq("GTC")
+        expect(order.to_api_params["time-in-force"]).to eq("GTC")
+      end
+
+      it "handles sell to open orders" do
+        leg = Tastytrade::OrderLeg.new(
+          action: Tastytrade::OrderAction::SELL_TO_OPEN,
+          symbol: "AAPL",
+          quantity: 100
+        )
+
+        order = Tastytrade::Order.new(
+          type: Tastytrade::OrderType::LIMIT,
+          legs: leg,
+          price: 150
+        )
+
+        # Sell orders should have Credit price effect
+        expect(order.to_api_params["price-effect"]).to eq("Credit")
+      end
+
+      it "handles buy to close orders" do
+        leg = Tastytrade::OrderLeg.new(
+          action: Tastytrade::OrderAction::BUY_TO_CLOSE,
+          symbol: "AAPL",
+          quantity: 100
+        )
+
+        order = Tastytrade::Order.new(
+          type: Tastytrade::OrderType::LIMIT,
+          legs: leg,
+          price: 150
+        )
+
+        # Buy orders should have Debit price effect
+        expect(order.to_api_params["price-effect"]).to eq("Debit")
+      end
+    end
+  end
+
+  describe Tastytrade::OrderLeg do
+    describe "edge cases" do
+      it "converts large quantities correctly" do
+        leg = Tastytrade::OrderLeg.new(
+          action: Tastytrade::OrderAction::BUY_TO_OPEN,
+          symbol: "SPY",
+          quantity: 10_000
+        )
+
+        expect(leg.quantity).to eq(10_000)
+        expect(leg.to_api_params["quantity"]).to eq(10_000)
+      end
+
+      it "handles string quantities" do
+        leg = Tastytrade::OrderLeg.new(
+          action: Tastytrade::OrderAction::BUY_TO_OPEN,
+          symbol: "AAPL",
+          quantity: "100"
+        )
+
+        expect(leg.quantity).to eq(100)
+      end
+    end
+  end
+
+  describe Tastytrade::Models::OrderResponse do
+    describe "edge cases" do
+      it "handles empty warnings array" do
+        response = Tastytrade::Models::OrderResponse.new(
+          "warnings" => [],
+          "errors" => []
+        )
+
+        expect(response.warnings).to eq([])
+        expect(response.errors).to eq([])
+      end
+
+      it "handles missing legs data" do
+        response = Tastytrade::Models::OrderResponse.new({})
+
+        expect(response.legs).to eq([])
+      end
+
+      it "handles complex fee calculation structure" do
+        response = Tastytrade::Models::OrderResponse.new(
+          "fee-calculation" => {
+            "total-fees" => "1.50",
+            "commission" => "0.65",
+            "regulatory-fees" => "0.01",
+            "clearing-fees" => "0.84"
+          }
+        )
+
+        expect(response.fee_calculations).to be_a(Hash)
+        expect(response.fee_calculations["total-fees"]).to eq("1.50")
+      end
+    end
+  end
+
+  describe Tastytrade::Instruments::Equity do
+    describe "#build_leg" do
+      let(:equity) { Tastytrade::Instruments::Equity.new("symbol" => "AAPL") }
+
+      it "builds legs with all action types" do
+        [
+          Tastytrade::OrderAction::BUY_TO_OPEN,
+          Tastytrade::OrderAction::SELL_TO_CLOSE,
+          Tastytrade::OrderAction::SELL_TO_OPEN,
+          Tastytrade::OrderAction::BUY_TO_CLOSE
+        ].each do |action|
+          leg = equity.build_leg(action: action, quantity: 100)
+
+          expect(leg.action).to eq(action)
+          expect(leg.symbol).to eq("AAPL")
+          expect(leg.quantity).to eq(100)
+          expect(leg.instrument_type).to eq("Equity")
+        end
+      end
+    end
+  end
+end