tastytrade 0.2.0 → 0.3.1

data/spec/tastytrade/cli_status_spec.rb

@@ -3,204 +3,193 @@
 require "spec_helper"
 require "tastytrade/cli"
 
-RSpec.describe "Tastytrade::CLI status command" do
-  def capture_stdout
-    original_stdout = $stdout
-    $stdout = StringIO.new
-    yield
-    $stdout.string
-  ensure
-    $stdout = original_stdout
-  end
+RSpec.describe "Tastytrade::CLI trading_status command" do
   let(:cli) { Tastytrade::CLI.new }
-  let(:config) { instance_double(Tastytrade::CLIConfig) }
   let(:session) { instance_double(Tastytrade::Session) }
-  let(:user) { instance_double(Tastytrade::Models::User, email: "test@example.com") }
+  let(:account) { instance_double(Tastytrade::Models::Account, account_number: "5WT0001") }
+  let(:config) { instance_double(Tastytrade::CLIConfig) }
+
+  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,
+      "day-trade-count" => 0
+    }
+  end
+
+  let(:trading_status) { Tastytrade::Models::TradingStatus.new(trading_status_data) }
 
   before do
+    allow(cli).to receive(:current_session).and_return(session)
+    allow(cli).to receive(:current_account).and_return(account)
     allow(cli).to receive(:config).and_return(config)
-    allow(config).to receive(:get).with("current_username").and_return("testuser")
-    allow(config).to receive(:get).with("environment").and_return("production")
+    allow(config).to receive(:get).with("current_account_number").and_return("5WT0001")
+    allow(account).to receive(:get_trading_status).with(session).and_return(trading_status)
   end
 
-  describe "#status" do
-    context "when not authenticated" do
+  describe "#trading_status" do
+    context "when authenticated with default account" do
+      it "displays trading status information" do
+        expect { cli.trading_status }.to output(/Trading Status for Account:.*5WT0001/).to_stdout
+      end
+
+      it "shows no restrictions when account is unrestricted" do
+        expect { cli.trading_status }.to output(/✓ No account restrictions/).to_stdout
+      end
+
+      it "displays trading permissions" do
+        output = capture_stdout { cli.trading_status }
+        expect(output).to include("Trading Permissions:")
+        expect(output).to include("Options Trading:")
+        expect(output).to include("Level 2")
+        expect(output).to include("Futures Trading:")
+        expect(output).to include("Cryptocurrency:")
+      end
+
+      it "displays account characteristics" do
+        output = capture_stdout { cli.trading_status }
+        expect(output).to include("Account Characteristics:")
+        expect(output).to include("Pattern Day Trader:")
+      end
+
+      it "displays additional information" do
+        output = capture_stdout { cli.trading_status }
+        expect(output).to include("Additional Information:")
+        expect(output).to include("Fee Schedule:")
+        expect(output).to include("standard")
+        expect(output).to include("Margin Type:")
+        expect(output).to include("REG_T")
+      end
+    end
+
+    context "when account has restrictions" do
+      let(:restricted_status_data) do
+        trading_status_data.merge(
+          "is-in-margin-call" => true,
+          "is-pattern-day-trader" => true,
+          "is-futures-closing-only" => true
+        )
+      end
+      let(:restricted_status) { Tastytrade::Models::TradingStatus.new(restricted_status_data) }
+
       before do
-        allow(cli).to receive(:current_session).and_return(nil)
+        allow(account).to receive(:get_trading_status).with(session).and_return(restricted_status)
       end
 
-      it "displays warning about no active session" do
-        expect { cli.status }.to output(/No active session/).to_stderr
+      it "displays account restrictions with warnings" do
+        output = capture_stdout { cli.trading_status }
+        expect(output).to include("⚠ Account Restrictions:")
+        expect(output).to include("• Margin Call")
+        expect(output).to include("• Pattern Day Trader")
+        expect(output).to include("• Futures Closing Only")
       end
 
-      it "suggests login command" do
-        expect { cli.status }.to output(/Run 'tastytrade login' to authenticate/).to_stdout
+      it "shows futures as closing only" do
+        output = capture_stdout { cli.trading_status }
+        expect(output).to include("Futures Trading:")
+        expect(output).to include("Closing Only")
       end
     end
 
-    context "when authenticated" do
+    context "with specific account option" do
+      let(:other_account) { instance_double(Tastytrade::Models::Account, account_number: "5WT0002") }
+
       before do
-        allow(cli).to receive(:current_session).and_return(session)
-        allow(session).to receive(:user).and_return(user)
-      end
-
-      context "without session expiration" do
-        before do
-          allow(session).to receive(:session_expiration).and_return(nil)
-          allow(session).to receive(:remember_token).and_return(nil)
-        end
-
-        it "displays session status" do
-          output = capture_stdout { cli.status }
-          expect(output).to include("Session Status:")
-          expect(output).to include("User: test@example.com")
-          expect(output).to include("Environment: production")
-          expect(output).to include("Status: Active")
-          expect(output).to include("Expires in: Unknown")
-          expect(output).to include("Remember token: Not available")
-          expect(output).to include("Auto-refresh: Disabled")
-        end
-      end
-
-      context "with non-expired session" do
-        let(:future_time) { Time.now + 3600 }
-
-        before do
-          allow(session).to receive(:session_expiration).and_return(future_time)
-          allow(session).to receive(:expired?).and_return(false)
-          allow(session).to receive(:time_until_expiry).and_return(3600)
-          allow(session).to receive(:remember_token).and_return("token123")
-        end
-
-        it "displays active status with time remaining" do
-          output = capture_stdout { cli.status }
-          expect(output).to include("Status: Active")
-          expect(output).to include("Expires in: 1h 0m")
-          expect(output).to include("Remember token: Available")
-          expect(output).to include("Auto-refresh: Enabled")
-        end
-      end
-
-      context "with expired session" do
-        let(:past_time) { Time.now - 3600 }
-
-        before do
-          allow(session).to receive(:session_expiration).and_return(past_time)
-          allow(session).to receive(:expired?).and_return(true)
-          allow(session).to receive(:remember_token).and_return(nil)
-        end
-
-        it "displays expired status" do
-          output = capture_stdout { cli.status }
-          expect(output).to include("Status: Expired")
-          expect(output).to include("Remember token: Not available")
-          expect(output).to include("Auto-refresh: Disabled")
-        end
+        allow(Tastytrade::Models::Account).to receive(:get)
+          .with(session, "5WT0002")
+          .and_return(other_account)
+        allow(other_account).to receive(:get_trading_status).with(session).and_return(trading_status)
+        cli.options = { account: "5WT0002" }
+      end
+
+      it "uses the specified account" do
+        expect(other_account).to receive(:get_trading_status).with(session)
+        cli.trading_status
       end
     end
-  end
 
-  describe "#refresh" do
     context "when not authenticated" do
       before do
         allow(cli).to receive(:current_session).and_return(nil)
       end
 
-      it "displays error and exits" do
-        expect { cli.refresh }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
-        end
-        expect {
-          begin
-            cli.refresh
-          rescue SystemExit
-          end
-        }.to output(/No active session to refresh/).to_stderr
+      it "requires authentication" do
+        expect { cli.trading_status }.to raise_error(SystemExit)
+          .and output(/You must be logged in/).to_stderr
       end
     end
 
-    context "when authenticated without remember token" do
+    context "when API call fails" do
       before do
-        allow(cli).to receive(:current_session).and_return(session)
-        allow(session).to receive(:remember_token).and_return(nil)
-      end
-
-      it "displays error about missing remember token" do
-        expect { cli.refresh }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
-        end
-        expect {
-          begin
-            cli.refresh
-          rescue SystemExit
-          end
-        }.to output(/No remember token available/).to_stderr
-      end
-
-      it "suggests using --remember flag" do
-        expect {
-          begin
-            cli.refresh
-          rescue SystemExit
-          end
-        }.to output(/Login with --remember flag/).to_stdout
+        allow(account).to receive(:get_trading_status)
+          .and_raise(Tastytrade::Error, "API error")
+      end
+
+      it "handles errors gracefully" do
+        expect { cli.trading_status }.to raise_error(SystemExit)
+          .and output(/Failed to fetch trading status/).to_stderr
       end
     end
 
-    context "when authenticated with remember token" do
-      let(:manager) { instance_double(Tastytrade::SessionManager) }
+    context "with PDT information" do
+      let(:pdt_status_data) do
+        trading_status_data.merge(
+          "is-pattern-day-trader" => true,
+          "day-trade-count" => 3,
+          "pdt-reset-on" => "2024-02-15"
+        )
+      end
+      let(:pdt_status) { Tastytrade::Models::TradingStatus.new(pdt_status_data) }
 
       before do
-        allow(cli).to receive(:current_session).and_return(session)
-        allow(session).to receive(:remember_token).and_return("token123")
-        allow(session).to receive(:user).and_return(user)
-        allow(Tastytrade::SessionManager).to receive(:new).and_return(manager)
-      end
-
-      context "on successful refresh" do
-        before do
-          allow(session).to receive(:refresh_session).and_return(session)
-          allow(session).to receive(:time_until_expiry).and_return(3600)
-          allow(manager).to receive(:save_session).and_return(true)
-        end
-
-        it "refreshes the session" do
-          expect(session).to receive(:refresh_session)
-          cli.refresh
-        end
-
-        it "saves the refreshed session" do
-          expect(manager).to receive(:save_session).with(session)
-          cli.refresh
-        end
-
-        it "displays success message" do
-          expect { cli.refresh }.to output(/Session refreshed successfully/).to_stdout
-        end
-
-        it "displays new expiration time" do
-          expect { cli.refresh }.to output(/Session expires in 1h 0m/).to_stdout
-        end
-      end
-
-      context "on refresh failure" do
-        before do
-          allow(session).to receive(:refresh_session)
-            .and_raise(Tastytrade::TokenRefreshError, "Invalid token")
-        end
-
-        it "displays error and exits" do
-          expect { cli.refresh }.to raise_error(SystemExit) do |error|
-            expect(error.status).to eq(1)
-          end
-          expect {
-            begin
-              cli.refresh
-            rescue SystemExit
-            end
-          }.to output(/Failed to refresh session: Invalid token/).to_stderr
-        end
+        allow(account).to receive(:get_trading_status).with(session).and_return(pdt_status)
+      end
+
+      it "displays PDT information" do
+        output = capture_stdout { cli.trading_status }
+        expect(output).to include("Pattern Day Trader:")
+        expect(output).to include("Yes")
+        expect(output).to include("Day Trade Count:")
+        expect(output).to include("3")
+        expect(output).to include("PDT Reset Date:")
+        expect(output).to include("2024-02-15")
       end
     end
   end
+
+  # Helper to capture stdout
+  def capture_stdout
+    original_stdout = $stdout
+    $stdout = StringIO.new
+    yield
+    $stdout.string
+  ensure
+    $stdout = original_stdout
+  end
 end

data/spec/tastytrade/file_store_spec.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tastytrade/file_store"
+require "tmpdir"
+
+RSpec.describe Tastytrade::FileStore do
+  let(:test_key) { "test_user_production" }
+  let(:test_value) { "test_token_123" }
+
+  let(:tmpdir) { Dir.mktmpdir }
+
+  before do
+    allow(described_class).to receive(:storage_directory).and_return(tmpdir)
+  end
+
+  after do
+    FileUtils.rm_rf(tmpdir) if File.exist?(tmpdir)
+  end
+
+  describe ".set" do
+    it "stores a credential successfully" do
+      expect(described_class.set(test_key, test_value)).to be true
+    end
+
+    it "creates the storage directory with proper permissions" do
+      described_class.set(test_key, test_value)
+      storage_dir = described_class.send(:storage_directory)
+      expect(File.exist?(storage_dir)).to be true
+      expect(File.stat(storage_dir).mode & 0o777).to eq(0o700)
+    end
+
+    it "creates credential files with proper permissions" do
+      described_class.set(test_key, test_value)
+      cred_path = described_class.send(:credential_path, test_key)
+      expect(File.stat(cred_path).mode & 0o777).to eq(0o600)
+    end
+
+    it "returns false for nil key" do
+      expect(described_class.set(nil, test_value)).to be false
+    end
+
+    it "returns false for nil value" do
+      expect(described_class.set(test_key, nil)).to be false
+    end
+
+    it "handles errors gracefully" do
+      allow(File).to receive(:write).and_raise(StandardError, "Write error")
+      expect(described_class.set(test_key, test_value)).to be false
+    end
+
+    it "converts symbols to strings" do
+      expect(described_class.set(:test_key, :test_value)).to be true
+      expect(described_class.get(:test_key)).to eq("test_value")
+    end
+  end
+
+  describe ".get" do
+    it "retrieves a credential successfully" do
+      described_class.set(test_key, test_value)
+      expect(described_class.get(test_key)).to eq(test_value)
+    end
+
+    it "returns nil for nil key" do
+      expect(described_class.get(nil)).to be nil
+    end
+
+    it "returns nil for non-existent key" do
+      expect(described_class.get("non_existent")).to be nil
+    end
+
+    it "handles errors gracefully" do
+      described_class.set(test_key, test_value)
+      allow(File).to receive(:read).and_raise(StandardError, "Read error")
+      expect(described_class.get(test_key)).to be nil
+    end
+
+    it "converts symbols to strings" do
+      described_class.set(:test_key, "value")
+      expect(described_class.get(:test_key)).to eq("value")
+    end
+  end
+
+  describe ".delete" do
+    it "deletes a credential successfully" do
+      described_class.set(test_key, test_value)
+      expect(described_class.delete(test_key)).to be true
+      expect(described_class.get(test_key)).to be nil
+    end
+
+    it "returns false for nil key" do
+      expect(described_class.delete(nil)).to be false
+    end
+
+    it "returns true for non-existent key" do
+      expect(described_class.delete("non_existent")).to be true
+    end
+
+    it "handles errors gracefully" do
+      described_class.set(test_key, test_value)
+      allow(File).to receive(:delete).and_raise(StandardError, "Delete error")
+      expect(described_class.delete(test_key)).to be false
+    end
+  end
+
+  describe ".available?" do
+    it "always returns true" do
+      expect(described_class.available?).to be true
+    end
+  end
+
+  describe "credential_path sanitization" do
+    it "sanitizes unsafe characters in keys" do
+      unsafe_key = "user@example.com/../../etc/passwd"
+      safe_path = described_class.send(:credential_path, unsafe_key)
+      expect(safe_path).to include("user@example.com_.._.._etc_passwd.cred")
+      expect(safe_path).not_to include("/../")
+    end
+
+    it "preserves allowed characters" do
+      safe_key = "user@example.com_production-123"
+      path = described_class.send(:credential_path, safe_key)
+      expect(path).to include("user@example.com_production-123.cred")
+    end
+  end
+end

data/spec/tastytrade/models/account_balance_spec.rb

@@ -244,4 +244,107 @@ RSpec.describe Tastytrade::Models::AccountBalance do
       expect(subject.equity_buying_power).to eq(BigDecimal("123456.789"))
     end
   end
+
+  describe "#derivative_buying_power_usage_percentage" do
+    it "calculates derivative BP usage correctly" do
+      # Used BP = 15000 - 12000 = 3000
+      # Percentage = 3000 / 15000 * 100 = 20%
+      expect(subject.derivative_buying_power_usage_percentage).to eq(BigDecimal("20.00"))
+    end
+
+    context "with zero derivative buying power" do
+      let(:balance_data) do
+        {
+          "account-number" => "5WX12345",
+          "derivative-buying-power" => "0",
+          "available-trading-funds" => "0"
+        }
+      end
+
+      it "returns zero" do
+        expect(subject.derivative_buying_power_usage_percentage).to eq(BigDecimal("0"))
+      end
+    end
+  end
+
+  describe "#day_trading_buying_power_usage_percentage" do
+    it "calculates day trading BP usage correctly" do
+      # Used BP = 40000 - 12000 = 28000
+      # Percentage = 28000 / 40000 * 100 = 70%
+      expect(subject.day_trading_buying_power_usage_percentage).to eq(BigDecimal("70.00"))
+    end
+  end
+
+  describe "#minimum_buying_power" do
+    it "returns the smallest buying power value" do
+      # Min of 20000, 15000, 40000 = 15000
+      expect(subject.minimum_buying_power).to eq(BigDecimal("15000.00"))
+    end
+  end
+
+  describe "#sufficient_buying_power?" do
+    context "with equity buying power" do
+      it "returns true when amount is less than available BP" do
+        expect(subject.sufficient_buying_power?(10000)).to be true
+        expect(subject.sufficient_buying_power?("10000.00")).to be true
+      end
+
+      it "returns false when amount exceeds available BP" do
+        expect(subject.sufficient_buying_power?(25000)).to be false
+      end
+
+      it "returns true when amount equals available BP" do
+        expect(subject.sufficient_buying_power?(20000)).to be true
+      end
+    end
+
+    context "with derivative buying power" do
+      it "checks against derivative BP when specified" do
+        expect(subject.sufficient_buying_power?(10000, buying_power_type: :derivative)).to be true
+        expect(subject.sufficient_buying_power?(20000, buying_power_type: :derivative)).to be false
+      end
+    end
+
+    context "with day trading buying power" do
+      it "checks against day trading BP when specified" do
+        expect(subject.sufficient_buying_power?(35000, buying_power_type: :day_trading)).to be true
+        expect(subject.sufficient_buying_power?(45000, buying_power_type: :day_trading)).to be false
+      end
+    end
+  end
+
+  describe "#buying_power_impact_percentage" do
+    context "with equity buying power" do
+      it "calculates impact percentage correctly" do
+        # 5000 / 20000 * 100 = 25%
+        expect(subject.buying_power_impact_percentage(5000)).to eq(BigDecimal("25.00"))
+      end
+
+      it "handles string amounts" do
+        expect(subject.buying_power_impact_percentage("5000.00")).to eq(BigDecimal("25.00"))
+      end
+    end
+
+    context "with derivative buying power" do
+      it "calculates against derivative BP when specified" do
+        # 3000 / 15000 * 100 = 20%
+        expect(subject.buying_power_impact_percentage(3000, buying_power_type: :derivative))
+          .to eq(BigDecimal("20.00"))
+      end
+    end
+
+    context "with zero 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_impact_percentage(1000)).to eq(BigDecimal("0"))
+      end
+    end
+  end
 end