tastytrade 0.2.0 → 0.3.1

data/spec/tastytrade/models/account_spec.rb

@@ -6,7 +6,7 @@ require "bigdecimal"
 RSpec.describe Tastytrade::Models::Account do
   let(:account_data) do
     {
-      "account-number" => "123456",
+      "account-number" => "5WT0001",
       "nickname" => "My Account",
       "account-type-name" => "Individual",
       "opened-at" => "2025-01-01T10:00:00Z",
@@ -25,7 +25,7 @@ RSpec.describe Tastytrade::Models::Account do
 
   describe "attributes" do
     it "parses account number" do
-      expect(account.account_number).to eq("123456")
+      expect(account.account_number).to eq("5WT0001")
     end
 
     it "parses nickname" do
@@ -79,7 +79,7 @@ RSpec.describe Tastytrade::Models::Account do
       expect(accounts).to be_an(Array)
       expect(accounts.size).to eq(2)
       expect(accounts.first).to be_a(described_class)
-      expect(accounts.first.account_number).to eq("123456")
+      expect(accounts.first.account_number).to eq("5WT0001")
       expect(accounts.last.account_number).to eq("789012")
     end
 
@@ -97,12 +97,12 @@ RSpec.describe Tastytrade::Models::Account do
     end
 
     it "returns single Account object" do
-      allow(session).to receive(:get).with("/accounts/123456/").and_return(response)
+      allow(session).to receive(:get).with("/accounts/5WT0001/").and_return(response)
 
-      account = described_class.get(session, "123456")
+      account = described_class.get(session, "5WT0001")
 
       expect(account).to be_a(described_class)
-      expect(account.account_number).to eq("123456")
+      expect(account.account_number).to eq("5WT0001")
     end
   end
 
@@ -110,7 +110,7 @@ RSpec.describe Tastytrade::Models::Account do
     let(:balance_data) do
       {
         "data" => {
-          "account-number" => "123456",
+          "account-number" => "5WT0001",
           "cash-balance" => "10000.00",
           "net-liquidating-value" => "15000.00"
         }
@@ -118,12 +118,12 @@ RSpec.describe Tastytrade::Models::Account do
     end
 
     it "returns balance data" do
-      allow(session).to receive(:get).with("/accounts/123456/balances/").and_return(balance_data)
+      allow(session).to receive(:get).with("/accounts/5WT0001/balances/").and_return(balance_data)
 
       balance = account.get_balances(session)
 
       expect(balance).to be_a(Tastytrade::Models::AccountBalance)
-      expect(balance.account_number).to eq("123456")
+      expect(balance.account_number).to eq("5WT0001")
       expect(balance.cash_balance).to eq(BigDecimal("10000.00"))
       expect(balance.net_liquidating_value).to eq(BigDecimal("15000.00"))
     end
@@ -142,7 +142,7 @@ RSpec.describe Tastytrade::Models::Account do
     end
 
     it "returns array of positions" do
-      allow(session).to receive(:get).with("/accounts/123456/positions/", {}).and_return(positions_data)
+      allow(session).to receive(:get).with("/accounts/5WT0001/positions/", {}).and_return(positions_data)
 
       positions = account.get_positions(session)
 
@@ -158,18 +158,46 @@ RSpec.describe Tastytrade::Models::Account do
     let(:status_data) do
       {
         "data" => {
-          "account-number" => "123456",
-          "is-pattern-day-trader" => false
+          "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"
         }
       }
     end
 
-    it "returns trading status data" do
-      allow(session).to receive(:get).with("/accounts/123456/trading-status/").and_return(status_data)
+    it "returns a TradingStatus object" do
+      allow(session).to receive(:get).with("/accounts/5WT0001/trading-status/").and_return(status_data)
 
       status = account.get_trading_status(session)
 
-      expect(status).to eq(status_data["data"])
+      expect(status).to be_a(Tastytrade::Models::TradingStatus)
+      expect(status.account_number).to eq("5WT0001")
+      expect(status.is_pattern_day_trader).to eq(false)
+      expect(status.options_level).to eq("Level 2")
     end
   end
 
@@ -202,5 +230,48 @@ RSpec.describe Tastytrade::Models::Account do
         expect(account.foreign?).to be false
       end
     end
+
+    describe "#get_transactions" do
+      let(:transaction_data) do
+        {
+          "data" => {
+            "items" => [
+              {
+                "id" => 12345,
+                "account-number" => "5WT0001",
+                "symbol" => "AAPL",
+                "transaction-type" => "Trade",
+                "value" => "-1500.00"
+              }
+            ]
+          }
+        }
+      end
+
+      it "fetches transactions for the account" do
+        allow(Tastytrade::Models::Transaction).to receive(:get_all)
+          .with(session, "5WT0001")
+          .and_return([])
+
+        account.get_transactions(session)
+        expect(Tastytrade::Models::Transaction).to have_received(:get_all).with(session, "5WT0001")
+      end
+
+      it "passes through filter options" do
+        options = {
+          start_date: Date.new(2023, 1, 1),
+          end_date: Date.new(2023, 12, 31),
+          symbol: "AAPL"
+        }
+
+        allow(Tastytrade::Models::Transaction).to receive(:get_all)
+          .with(session, "5WT0001", **options)
+          .and_return([])
+
+        account.get_transactions(session, **options)
+        expect(Tastytrade::Models::Transaction).to have_received(:get_all)
+          .with(session, "5WT0001", **options)
+      end
+    end
   end
 end

data/spec/tastytrade/models/buying_power_effect_spec.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "bigdecimal"
+
+RSpec.describe Tastytrade::Models::BuyingPowerEffect do
+  let(:buying_power_effect_data) do
+    {
+      "change-in-margin-requirement" => "-125.0",
+      "change-in-buying-power" => "-125.004",
+      "current-buying-power" => "1000.0",
+      "new-buying-power" => "874.996",
+      "isolated-order-margin-requirement" => "-125.0",
+      "is-spread" => false,
+      "impact" => "125.004",
+      "effect" => "Debit"
+    }
+  end
+
+  subject { described_class.new(buying_power_effect_data) }
+
+  describe "#initialize" do
+    it "parses all attributes correctly" do
+      expect(subject.change_in_margin_requirement).to eq(BigDecimal("-125.0"))
+      expect(subject.change_in_buying_power).to eq(BigDecimal("-125.004"))
+      expect(subject.current_buying_power).to eq(BigDecimal("1000.0"))
+      expect(subject.new_buying_power).to eq(BigDecimal("874.996"))
+      expect(subject.isolated_order_margin_requirement).to eq(BigDecimal("-125.0"))
+      expect(subject.is_spread).to eq(false)
+      expect(subject.impact).to eq(BigDecimal("125.004"))
+      expect(subject.effect).to eq("Debit")
+    end
+
+    context "with nil values" do
+      let(:buying_power_effect_data) do
+        {
+          "change-in-margin-requirement" => nil,
+          "change-in-buying-power" => "",
+          "current-buying-power" => "1000.0",
+          "effect" => "Debit"
+        }
+      end
+
+      it "handles nil and empty values gracefully" do
+        expect(subject.change_in_margin_requirement).to be_nil
+        expect(subject.change_in_buying_power).to be_nil
+        expect(subject.current_buying_power).to eq(BigDecimal("1000.0"))
+      end
+    end
+  end
+
+  describe "#buying_power_usage_percentage" do
+    it "calculates the percentage correctly" do
+      # 125.004 / 1000.0 * 100 = 12.5004
+      expect(subject.buying_power_usage_percentage).to eq(BigDecimal("12.50"))
+    end
+
+    context "with zero current buying power" do
+      let(:buying_power_effect_data) do
+        {
+          "current-buying-power" => "0",
+          "impact" => "100.0"
+        }
+      end
+
+      it "returns zero" do
+        expect(subject.buying_power_usage_percentage).to eq(BigDecimal("0"))
+      end
+    end
+
+    context "with nil current buying power" do
+      let(:buying_power_effect_data) do
+        {
+          "current-buying-power" => nil,
+          "impact" => "100.0"
+        }
+      end
+
+      it "returns zero" do
+        expect(subject.buying_power_usage_percentage).to eq(BigDecimal("0"))
+      end
+    end
+
+    context "using change-in-buying-power when impact is nil" do
+      let(:buying_power_effect_data) do
+        {
+          "change-in-buying-power" => "-200.50",
+          "current-buying-power" => "1000.0",
+          "impact" => nil
+        }
+      end
+
+      it "uses the absolute value of change-in-buying-power" do
+        # 200.50 / 1000.0 * 100 = 20.05
+        expect(subject.buying_power_usage_percentage).to eq(BigDecimal("20.05"))
+      end
+    end
+  end
+
+  describe "#exceeds_threshold?" do
+    it "returns true when usage exceeds threshold" do
+      expect(subject.exceeds_threshold?(10)).to be true
+      expect(subject.exceeds_threshold?("10.0")).to be true
+    end
+
+    it "returns false when usage is below threshold" do
+      expect(subject.exceeds_threshold?(15)).to be false
+      expect(subject.exceeds_threshold?(20)).to be false
+    end
+
+    it "returns false when usage equals threshold" do
+      expect(subject.exceeds_threshold?(12.50)).to be false
+    end
+  end
+
+  describe "#buying_power_change_amount" do
+    it "returns the absolute value of the change" do
+      expect(subject.buying_power_change_amount).to eq(BigDecimal("125.004"))
+    end
+
+    context "with positive change" do
+      let(:buying_power_effect_data) do
+        {
+          "change-in-buying-power" => "150.00",
+          "current-buying-power" => "1000.0"
+        }
+      end
+
+      it "returns the absolute value" do
+        expect(subject.buying_power_change_amount).to eq(BigDecimal("150.00"))
+      end
+    end
+
+    context "using impact when change-in-buying-power is nil" do
+      let(:buying_power_effect_data) do
+        {
+          "change-in-buying-power" => nil,
+          "impact" => "75.50"
+        }
+      end
+
+      it "returns the impact absolute value" do
+        expect(subject.buying_power_change_amount).to eq(BigDecimal("75.50"))
+      end
+    end
+
+    context "with all nil values" do
+      let(:buying_power_effect_data) do
+        {
+          "change-in-buying-power" => nil,
+          "impact" => nil
+        }
+      end
+
+      it "returns zero" do
+        expect(subject.buying_power_change_amount).to eq(BigDecimal("0"))
+      end
+    end
+  end
+
+  describe "#debit?" do
+    it "returns true for debit effects" do
+      expect(subject.debit?).to be true
+    end
+
+    context "with credit effect" do
+      let(:buying_power_effect_data) do
+        {
+          "effect" => "Credit",
+          "change-in-buying-power" => "100.0"
+        }
+      end
+
+      it "returns false" do
+        expect(subject.debit?).to be false
+      end
+    end
+
+    context "with negative change and no effect field" do
+      let(:buying_power_effect_data) do
+        {
+          "change-in-buying-power" => "-50.0",
+          "effect" => nil
+        }
+      end
+
+      it "returns true based on negative change" do
+        expect(subject.debit?).to be true
+      end
+    end
+
+    context "with positive change and no effect field" do
+      let(:buying_power_effect_data) do
+        {
+          "change-in-buying-power" => "50.0",
+          "effect" => nil
+        }
+      end
+
+      it "returns false based on positive change" do
+        expect(subject.debit?).to be false
+      end
+    end
+  end
+
+  describe "#credit?" do
+    context "with credit effect" do
+      let(:buying_power_effect_data) do
+        {
+          "effect" => "Credit",
+          "change-in-buying-power" => "100.0"
+        }
+      end
+
+      it "returns true" do
+        expect(subject.credit?).to be true
+      end
+    end
+
+    it "returns false for debit effects" do
+      expect(subject.credit?).to be false
+    end
+
+    context "with positive change and no effect field" do
+      let(:buying_power_effect_data) do
+        {
+          "change-in-buying-power" => "75.0",
+          "effect" => nil
+        }
+      end
+
+      it "returns true based on positive change" do
+        expect(subject.credit?).to be true
+      end
+    end
+  end
+
+  describe "attribute readers" do
+    it "provides access to all attributes" do
+      expect(subject).to respond_to(:change_in_margin_requirement)
+      expect(subject).to respond_to(:change_in_buying_power)
+      expect(subject).to respond_to(:current_buying_power)
+      expect(subject).to respond_to(:new_buying_power)
+      expect(subject).to respond_to(:isolated_order_margin_requirement)
+      expect(subject).to respond_to(:is_spread)
+      expect(subject).to respond_to(:impact)
+      expect(subject).to respond_to(:effect)
+    end
+  end
+end

data/spec/tastytrade/models/live_order_json_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Tastytrade::Models::LiveOrder#to_h" do
+  let(:order_data) do
+    {
+      "id" => "12345",
+      "account-number" => "5WZ38925",
+      "status" => "Live",
+      "cancellable" => true,
+      "editable" => true,
+      "edited" => false,
+      "time-in-force" => "Day",
+      "order-type" => "Limit",
+      "size" => 100,
+      "price" => "150.50",
+      "price-effect" => "Debit",
+      "underlying-symbol" => "AAPL",
+      "underlying-instrument-type" => "Equity",
+      "stop-trigger" => "148.00",
+      "gtc-date" => "2024-12-31",
+      "created-at" => "2024-01-01T10:00:00Z",
+      "updated-at" => "2024-01-01T10:05:00Z",
+      "received-at" => "2024-01-01T10:00:01Z",
+      "routed-at" => "2024-01-01T10:00:02Z",
+      "live-at" => "2024-01-01T10:00:03Z",
+      "legs" => [
+        {
+          "symbol" => "AAPL",
+          "instrument-type" => "Equity",
+          "action" => "Buy to Open",
+          "quantity" => 100,
+          "remaining-quantity" => 75,
+          "fill-price" => "150.25",
+          "fills" => [
+            {
+              "ext-exec-id" => "EXT123",
+              "fill-id" => "FILL123",
+              "quantity" => 25,
+              "fill-price" => "150.25",
+              "filled-at" => "2024-01-01T10:03:00Z",
+              "destination-venue" => "NASDAQ"
+            }
+          ]
+        }
+      ]
+    }
+  end
+
+  let(:order) { Tastytrade::Models::LiveOrder.new(order_data) }
+
+  it "converts order to hash format" do
+    hash = order.to_h
+
+    expect(hash).to be_a(Hash)
+    expect(hash[:id]).to eq("12345")
+    expect(hash[:account_number]).to eq("5WZ38925")
+    expect(hash[:status]).to eq("Live")
+    expect(hash[:cancellable]).to be true
+    expect(hash[:editable]).to be true
+    expect(hash[:edited]).to be false
+    expect(hash[:time_in_force]).to eq("Day")
+    expect(hash[:order_type]).to eq("Limit")
+    expect(hash[:size]).to eq(100)
+    expect(hash[:price]).to eq("150.5")
+    expect(hash[:price_effect]).to eq("Debit")
+    expect(hash[:underlying_symbol]).to eq("AAPL")
+    expect(hash[:underlying_instrument_type]).to eq("Equity")
+    expect(hash[:stop_trigger]).to eq("148.0")
+    expect(hash[:gtc_date]).to eq("2024-12-31")
+    expect(hash[:remaining_quantity]).to eq(75)
+    expect(hash[:filled_quantity]).to eq(25)
+  end
+
+  it "includes timestamp fields in ISO8601 format" do
+    hash = order.to_h
+
+    expect(hash[:created_at]).to eq("2024-01-01T10:00:00Z")
+    expect(hash[:updated_at]).to eq("2024-01-01T10:05:00Z")
+    expect(hash[:received_at]).to eq("2024-01-01T10:00:01Z")
+    expect(hash[:routed_at]).to eq("2024-01-01T10:00:02Z")
+    expect(hash[:live_at]).to eq("2024-01-01T10:00:03Z")
+  end
+
+  it "includes leg information" do
+    hash = order.to_h
+
+    expect(hash[:legs]).to be_an(Array)
+    expect(hash[:legs].size).to eq(1)
+
+    leg = hash[:legs].first
+    expect(leg[:symbol]).to eq("AAPL")
+    expect(leg[:instrument_type]).to eq("Equity")
+    expect(leg[:action]).to eq("Buy to Open")
+    expect(leg[:quantity]).to eq(100)
+    expect(leg[:remaining_quantity]).to eq(75)
+    expect(leg[:filled_quantity]).to eq(25)
+    expect(leg[:fill_price]).to eq("150.25")
+  end
+
+  it "includes fill information" do
+    hash = order.to_h
+    leg = hash[:legs].first
+    fills = leg[:fills]
+
+    expect(fills).to be_an(Array)
+    expect(fills.size).to eq(1)
+
+    fill = fills.first
+    expect(fill[:ext_exec_id]).to eq("EXT123")
+    expect(fill[:fill_id]).to eq("FILL123")
+    expect(fill[:quantity]).to eq(25)
+    expect(fill[:fill_price]).to eq("150.25")
+    expect(fill[:filled_at]).to eq("2024-01-01T10:03:00Z")
+    expect(fill[:destination_venue]).to eq("NASDAQ")
+  end
+
+  it "excludes nil values from hash" do
+    minimal_order_data = {
+      "id" => "12345",
+      "status" => "Live",
+      "legs" => []
+    }
+    minimal_order = Tastytrade::Models::LiveOrder.new(minimal_order_data)
+    hash = minimal_order.to_h
+
+    expect(hash).not_to have_key(:price)
+    expect(hash).not_to have_key(:stop_trigger)
+    expect(hash).not_to have_key(:gtc_date)
+    expect(hash).not_to have_key(:filled_at)
+    expect(hash).not_to have_key(:cancelled_at)
+  end
+
+  it "can be serialized to JSON" do
+    hash = order.to_h
+    json = JSON.generate(hash)
+    parsed = JSON.parse(json)
+
+    expect(parsed["id"]).to eq("12345")
+    expect(parsed["status"]).to eq("Live")
+    expect(parsed["legs"]).to be_an(Array)
+  end
+end