tastytrade 0.2.0

data/spec/tastytrade/models/account_balance_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "bigdecimal"
+
+RSpec.describe Tastytrade::Models::AccountBalance do
+  let(:balance_data) do
+    {
+      "account-number" => "5WX12345",
+      "cash-balance" => "10000.50",
+      "long-equity-value" => "25000.75",
+      "short-equity-value" => "5000.25",
+      "long-derivative-value" => "3000.00",
+      "short-derivative-value" => "1500.00",
+      "net-liquidating-value" => "42001.00",
+      "equity-buying-power" => "20000.00",
+      "derivative-buying-power" => "15000.00",
+      "day-trading-buying-power" => "40000.00",
+      "available-trading-funds" => "12000.00",
+      "margin-equity" => "42001.00",
+      "pending-cash" => "500.00",
+      "pending-margin-interest" => "25.50",
+      "effective-trading-funds" => "11974.50",
+      "updated-at" => "2024-01-15T10:30:00Z"
+    }
+  end
+
+  subject { described_class.new(balance_data) }
+
+  describe "#initialize" do
+    it "parses account number" do
+      expect(subject.account_number).to eq("5WX12345")
+    end
+
+    it "converts monetary values to BigDecimal" do
+      expect(subject.cash_balance).to be_a(BigDecimal)
+      expect(subject.cash_balance).to eq(BigDecimal("10000.50"))
+    end
+
+    it "parses all balance fields correctly" do
+      expect(subject.long_equity_value).to eq(BigDecimal("25000.75"))
+      expect(subject.short_equity_value).to eq(BigDecimal("5000.25"))
+      expect(subject.long_derivative_value).to eq(BigDecimal("3000.00"))
+      expect(subject.short_derivative_value).to eq(BigDecimal("1500.00"))
+      expect(subject.net_liquidating_value).to eq(BigDecimal("42001.00"))
+      expect(subject.equity_buying_power).to eq(BigDecimal("20000.00"))
+      expect(subject.derivative_buying_power).to eq(BigDecimal("15000.00"))
+      expect(subject.day_trading_buying_power).to eq(BigDecimal("40000.00"))
+      expect(subject.available_trading_funds).to eq(BigDecimal("12000.00"))
+      expect(subject.margin_equity).to eq(BigDecimal("42001.00"))
+      expect(subject.pending_cash).to eq(BigDecimal("500.00"))
+      expect(subject.pending_margin_interest).to eq(BigDecimal("25.50"))
+      expect(subject.effective_trading_funds).to eq(BigDecimal("11974.50"))
+    end
+
+    it "parses updated_at as Time" do
+      expect(subject.updated_at).to be_a(Time)
+      expect(subject.updated_at.iso8601).to eq("2024-01-15T10:30:00Z")
+    end
+
+    context "with nil values" do
+      let(:balance_data) do
+        {
+          "account-number" => "5WX12345",
+          "cash-balance" => nil,
+          "long-equity-value" => "",
+          "net-liquidating-value" => "1000.00",
+          "equity-buying-power" => "1000.00",
+          "available-trading-funds" => "1000.00"
+        }
+      end
+
+      it "converts nil and empty strings to zero" do
+        expect(subject.cash_balance).to eq(BigDecimal("0"))
+        expect(subject.long_equity_value).to eq(BigDecimal("0"))
+      end
+    end
+
+    context "with string numbers" do
+      let(:balance_data) do
+        {
+          "account-number" => "5WX12345",
+          "cash-balance" => "1234.567890",
+          "net-liquidating-value" => "1234.567890",
+          "equity-buying-power" => "1000.00",
+          "available-trading-funds" => "1000.00"
+        }
+      end
+
+      it "maintains precision with BigDecimal" do
+        expect(subject.cash_balance.to_s("F")).to eq("1234.56789")
+        expect(subject.net_liquidating_value.to_s("F")).to eq("1234.56789")
+      end
+    end
+  end
+
+  describe "#buying_power_usage_percentage" do
+    context "with normal usage" do
+      it "calculates the percentage correctly" do
+        # Used BP = 20000 - 12000 = 8000
+        # Percentage = 8000 / 20000 * 100 = 40%
+        expect(subject.buying_power_usage_percentage).to eq(BigDecimal("40.00"))
+      end
+    end
+
+    context "with zero equity buying power" do
+      let(:balance_data) do
+        {
+          "account-number" => "5WX12345",
+          "equity-buying-power" => "0",
+          "available-trading-funds" => "0"
+        }
+      end
+
+      it "returns zero" do
+        expect(subject.buying_power_usage_percentage).to eq(BigDecimal("0"))
+      end
+    end
+
+    context "with full usage" do
+      let(:balance_data) do
+        {
+          "account-number" => "5WX12345",
+          "equity-buying-power" => "10000.00",
+          "available-trading-funds" => "0.00"
+        }
+      end
+
+      it "returns 100%" do
+        expect(subject.buying_power_usage_percentage).to eq(BigDecimal("100.00"))
+      end
+    end
+
+    context "with high precision" do
+      let(:balance_data) do
+        {
+          "account-number" => "5WX12345",
+          "equity-buying-power" => "10000.00",
+          "available-trading-funds" => "3333.33"
+        }
+      end
+
+      it "rounds to 2 decimal places" do
+        # Used BP = 10000 - 3333.33 = 6666.67
+        # Percentage = 6666.67 / 10000 * 100 = 66.6667
+        expect(subject.buying_power_usage_percentage).to eq(BigDecimal("66.67"))
+      end
+    end
+  end
+
+  describe "#high_buying_power_usage?" do
+    context "with default threshold (80%)" do
+      it "returns false when usage is below 80%" do
+        expect(subject.high_buying_power_usage?).to be false
+      end
+
+      context "with high usage" do
+        let(:balance_data) do
+          {
+            "account-number" => "5WX12345",
+            "equity-buying-power" => "10000.00",
+            "available-trading-funds" => "1500.00"
+          }
+        end
+
+        it "returns true when usage is above 80%" do
+          # Usage = 85%
+          expect(subject.high_buying_power_usage?).to be true
+        end
+      end
+    end
+
+    context "with custom threshold" do
+      it "uses the provided threshold" do
+        expect(subject.high_buying_power_usage?(30)).to be true
+        expect(subject.high_buying_power_usage?(50)).to be false
+      end
+    end
+  end
+
+  describe "#total_equity_value" do
+    it "sums long and short equity values" do
+      # 25000.75 + 5000.25 = 30001.00
+      expect(subject.total_equity_value).to eq(BigDecimal("30001.00"))
+    end
+  end
+
+  describe "#total_derivative_value" do
+    it "sums long and short derivative values" do
+      # 3000.00 + 1500.00 = 4500.00
+      expect(subject.total_derivative_value).to eq(BigDecimal("4500.00"))
+    end
+  end
+
+  describe "#total_market_value" do
+    it "sums all market values" do
+      # 30001.00 + 4500.00 = 34501.00
+      expect(subject.total_market_value).to eq(BigDecimal("34501.00"))
+    end
+  end
+
+  describe "attribute readers" do
+    it "provides access to all balance fields" do
+      expect(subject).to respond_to(:account_number)
+      expect(subject).to respond_to(:cash_balance)
+      expect(subject).to respond_to(:long_equity_value)
+      expect(subject).to respond_to(:short_equity_value)
+      expect(subject).to respond_to(:long_derivative_value)
+      expect(subject).to respond_to(:short_derivative_value)
+      expect(subject).to respond_to(:net_liquidating_value)
+      expect(subject).to respond_to(:equity_buying_power)
+      expect(subject).to respond_to(:derivative_buying_power)
+      expect(subject).to respond_to(:day_trading_buying_power)
+      expect(subject).to respond_to(:available_trading_funds)
+      expect(subject).to respond_to(:margin_equity)
+      expect(subject).to respond_to(:pending_cash)
+      expect(subject).to respond_to(:pending_margin_interest)
+      expect(subject).to respond_to(:effective_trading_funds)
+      expect(subject).to respond_to(:updated_at)
+    end
+  end
+
+  describe "BigDecimal precision" do
+    let(:balance_data) do
+      {
+        "account-number" => "5WX12345",
+        "cash-balance" => "0.01",
+        "net-liquidating-value" => "999999.99",
+        "equity-buying-power" => "123456.789",
+        "available-trading-funds" => "0.001"
+      }
+    end
+
+    it "handles small values correctly" do
+      expect(subject.cash_balance).to eq(BigDecimal("0.01"))
+      expect(subject.available_trading_funds).to eq(BigDecimal("0.001"))
+    end
+
+    it "handles large values correctly" do
+      expect(subject.net_liquidating_value).to eq(BigDecimal("999999.99"))
+    end
+
+    it "maintains precision beyond 2 decimal places" do
+      expect(subject.equity_buying_power).to eq(BigDecimal("123456.789"))
+    end
+  end
+end

data/spec/tastytrade/models/account_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "bigdecimal"
+
+RSpec.describe Tastytrade::Models::Account do
+  let(:account_data) do
+    {
+      "account-number" => "123456",
+      "nickname" => "My Account",
+      "account-type-name" => "Individual",
+      "opened-at" => "2025-01-01T10:00:00Z",
+      "is-closed" => false,
+      "day-trader-status" => false,
+      "is-futures-approved" => true,
+      "margin-or-cash" => "Margin",
+      "is-foreign" => false,
+      "created-at" => "2025-01-01T10:00:00Z",
+      "is-test-drive" => false
+    }
+  end
+
+  let(:session) { instance_double(Tastytrade::Session) }
+  subject(:account) { described_class.new(account_data) }
+
+  describe "attributes" do
+    it "parses account number" do
+      expect(account.account_number).to eq("123456")
+    end
+
+    it "parses nickname" do
+      expect(account.nickname).to eq("My Account")
+    end
+
+    it "parses account type" do
+      expect(account.account_type_name).to eq("Individual")
+    end
+
+    it "parses opened_at as Time" do
+      expect(account.opened_at).to be_a(Time)
+      expect(account.opened_at.year).to eq(2025)
+    end
+
+    it "parses boolean fields" do
+      expect(account.is_closed).to be false
+      expect(account.day_trader_status).to be false
+      expect(account.is_futures_approved).to be true
+    end
+
+    it "parses optional fields" do
+      expect(account.external_id).to be_nil
+      expect(account.closed_at).to be_nil
+    end
+  end
+
+  describe ".get_all" do
+    let(:response) do
+      {
+        "data" => {
+          "items" => [
+            {
+              "account" => account_data,
+              "authority-level" => "owner"
+            },
+            {
+              "account" => account_data.merge("account-number" => "789012"),
+              "authority-level" => "owner"
+            }
+          ]
+        }
+      }
+    end
+
+    it "returns array of Account objects" do
+      allow(session).to receive(:get).with("/customers/me/accounts/", {}).and_return(response)
+
+      accounts = described_class.get_all(session)
+
+      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.last.account_number).to eq("789012")
+    end
+
+    it "includes closed accounts when specified" do
+      allow(session).to receive(:get).with("/customers/me/accounts/", { "include-closed" => true })
+                                     .and_return(response)
+
+      described_class.get_all(session, include_closed: true)
+    end
+  end
+
+  describe ".get" do
+    let(:response) do
+      { "data" => account_data }
+    end
+
+    it "returns single Account object" do
+      allow(session).to receive(:get).with("/accounts/123456/").and_return(response)
+
+      account = described_class.get(session, "123456")
+
+      expect(account).to be_a(described_class)
+      expect(account.account_number).to eq("123456")
+    end
+  end
+
+  describe "#get_balances" do
+    let(:balance_data) do
+      {
+        "data" => {
+          "account-number" => "123456",
+          "cash-balance" => "10000.00",
+          "net-liquidating-value" => "15000.00"
+        }
+      }
+    end
+
+    it "returns balance data" do
+      allow(session).to receive(:get).with("/accounts/123456/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.cash_balance).to eq(BigDecimal("10000.00"))
+      expect(balance.net_liquidating_value).to eq(BigDecimal("15000.00"))
+    end
+  end
+
+  describe "#get_positions" do
+    let(:positions_data) do
+      {
+        "data" => {
+          "items" => [
+            { "symbol" => "AAPL", "quantity" => "100" },
+            { "symbol" => "MSFT", "quantity" => "50" }
+          ]
+        }
+      }
+    end
+
+    it "returns array of positions" do
+      allow(session).to receive(:get).with("/accounts/123456/positions/", {}).and_return(positions_data)
+
+      positions = account.get_positions(session)
+
+      expect(positions).to be_an(Array)
+      expect(positions.size).to eq(2)
+      expect(positions.first).to be_a(Tastytrade::Models::CurrentPosition)
+      expect(positions.first.symbol).to eq("AAPL")
+      expect(positions.first.quantity).to eq(BigDecimal("100"))
+    end
+  end
+
+  describe "#get_trading_status" do
+    let(:status_data) do
+      {
+        "data" => {
+          "account-number" => "123456",
+          "is-pattern-day-trader" => false
+        }
+      }
+    end
+
+    it "returns trading status data" do
+      allow(session).to receive(:get).with("/accounts/123456/trading-status/").and_return(status_data)
+
+      status = account.get_trading_status(session)
+
+      expect(status).to eq(status_data["data"])
+    end
+  end
+
+  describe "boolean helper methods" do
+    describe "#closed?" do
+      it "returns true when is_closed is true" do
+        account = described_class.new(account_data.merge("is-closed" => true))
+        expect(account.closed?).to be true
+      end
+
+      it "returns false when is_closed is false" do
+        expect(account.closed?).to be false
+      end
+    end
+
+    describe "#futures_approved?" do
+      it "returns true when is_futures_approved is true" do
+        expect(account.futures_approved?).to be true
+      end
+    end
+
+    describe "#test_drive?" do
+      it "returns false when is_test_drive is false" do
+        expect(account.test_drive?).to be false
+      end
+    end
+
+    describe "#foreign?" do
+      it "returns false when is_foreign is false" do
+        expect(account.foreign?).to be false
+      end
+    end
+  end
+end

data/spec/tastytrade/models/base_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Tastytrade::Models::Base do
+  let(:test_class) do
+    Class.new(described_class) do
+      attr_reader :test_attr, :parsed_time
+
+      private
+
+      def parse_attributes
+        @test_attr = @data["test-attr"]
+        @parsed_time = parse_time(@data["time-field"])
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "accepts hash with string keys" do
+      instance = test_class.new("test-attr" => "value")
+      expect(instance.test_attr).to eq("value")
+    end
+
+    it "accepts hash with symbol keys" do
+      instance = test_class.new(test_attr: "value")
+      expect(instance.data["test_attr"]).to eq("value")
+    end
+
+    it "stores raw data" do
+      data = { "test-attr" => "value", "other" => "data" }
+      instance = test_class.new(data)
+      expect(instance.data).to eq(data.transform_keys(&:to_s))
+    end
+  end
+
+  describe "#parse_time" do
+    let(:instance) { test_class.new({}) }
+
+    it "parses valid ISO 8601 datetime" do
+      instance = test_class.new("time-field" => "2025-07-30T10:30:00Z")
+      expect(instance.parsed_time).to be_a(Time)
+      expect(instance.parsed_time.year).to eq(2025)
+    end
+
+    it "returns nil for nil value" do
+      instance = test_class.new("time-field" => nil)
+      expect(instance.parsed_time).to be_nil
+    end
+
+    it "returns nil for empty string" do
+      instance = test_class.new("time-field" => "")
+      expect(instance.parsed_time).to be_nil
+    end
+
+    it "returns nil for invalid datetime" do
+      instance = test_class.new("time-field" => "not a date")
+      expect(instance.parsed_time).to be_nil
+    end
+  end
+end