tastytrade 0.2.0 → 0.3.0

data/lib/tastytrade/session.rb

@@ -7,6 +7,26 @@ module Tastytrade
   class Session
     attr_reader :user, :session_token, :remember_token, :is_test, :session_expiration
 
+    # Create a session from environment variables
+    #
+    # @return [Session, nil] Session instance or nil if environment variables not set
+    def self.from_environment
+      username = ENV["TASTYTRADE_USERNAME"] || ENV["TT_USERNAME"]
+      password = ENV["TASTYTRADE_PASSWORD"] || ENV["TT_PASSWORD"]
+
+      return nil unless username && password
+
+      remember = ENV["TASTYTRADE_REMEMBER"]&.downcase == "true" || ENV["TT_REMEMBER"]&.downcase == "true"
+      is_test = ENV["TASTYTRADE_ENVIRONMENT"]&.downcase == "sandbox" || ENV["TT_ENVIRONMENT"]&.downcase == "sandbox"
+
+      new(
+        username: username,
+        password: password,
+        remember_me: remember,
+        is_test: is_test
+      )
+    end
+
     # Initialize a new session
     #
     # @param username [String] Tastytrade username
@@ -47,9 +67,14 @@ module Tastytrade
     #
     # @return [Boolean] True if session is valid
     def validate
+      warn "DEBUG: Validating session, user=#{@user&.email}" if ENV["DEBUG_SESSION"]
       response = get("/sessions/validate")
+      if ENV["DEBUG_SESSION"]
+        warn "DEBUG: Validate response email=#{response["data"]["email"]}, user email=#{@user&.email}"
+      end
       response["data"]["email"] == @user.email
-    rescue Tastytrade::Error
+    rescue Tastytrade::Error => e
+      warn "DEBUG: Validate error: #{e.message}" if ENV["DEBUG_SESSION"]
       false
     end
 

data/lib/tastytrade/session_manager.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "keyring_store"
+require_relative "file_store"
+require_relative "cli_config"
 require "json"
 
 module Tastytrade
@@ -29,9 +30,12 @@ module Tastytrade
       # Save session expiration if available
       save_session_expiration(session.session_expiration) if session.session_expiration
 
+      # Save user data
+      save_user_data(session.user) if session.user
+
       if remember && session.remember_token
         save_remember_token(session.remember_token)
-        save_password(password) if password && KeyringStore.available?
+        save_password(password) if password && FileStore.available?
       end
 
       # Save session metadata
@@ -56,6 +60,7 @@ module Tastytrade
       {
         session_token: token,
         remember_token: load_remember_token,
+        user_data: load_user_data,
         session_expiration: load_session_expiration,
         username: username,
         environment: environment
@@ -87,10 +92,10 @@ module Tastytrade
 
     # Clear all stored session data
     def clear_session!
-      KeyringStore.delete(token_key)
-      KeyringStore.delete(remember_token_key)
-      KeyringStore.delete(password_key)
-      KeyringStore.delete(session_expiration_key)
+      FileStore.delete(token_key)
+      FileStore.delete(remember_token_key)
+      FileStore.delete(password_key)
+      FileStore.delete(session_expiration_key)
 
       config = CLIConfig.new
       config.delete("current_username")
@@ -122,39 +127,63 @@ module Tastytrade
       "#{SESSION_KEY_PREFIX}_expiration_#{username}_#{environment}"
     end
 
+    def user_data_key
+      "user_data_#{username}_#{environment}"
+    end
+
     def save_token(token)
-      KeyringStore.set(token_key, token)
+      result = FileStore.set(token_key, token)
+      result
     end
 
     def load_token
-      KeyringStore.get(token_key)
+      FileStore.get(token_key)
     end
 
     def save_remember_token(token)
-      KeyringStore.set(remember_token_key, token)
+      FileStore.set(remember_token_key, token)
     end
 
     def load_remember_token
-      KeyringStore.get(remember_token_key)
+      FileStore.get(remember_token_key)
     end
 
     def save_password(password)
-      KeyringStore.set(password_key, password)
+      FileStore.set(password_key, password)
     end
 
     def load_password
-      KeyringStore.get(password_key)
+      FileStore.get(password_key)
     end
 
     def save_session_expiration(expiration)
-      KeyringStore.set(session_expiration_key, expiration.iso8601)
+      FileStore.set(session_expiration_key, expiration.iso8601)
     end
 
     def load_session_expiration
-      value = KeyringStore.get(session_expiration_key)
+      value = FileStore.get(session_expiration_key)
       value ? Time.parse(value).iso8601 : nil
     rescue StandardError
       nil
     end
+
+    def save_user_data(user)
+      return unless user
+      # Save minimal user data needed for session validation
+      user_data = {
+        email: user.email,
+        username: user.username,
+        external_id: user.external_id
+      }
+      FileStore.set(user_data_key, JSON.generate(user_data))
+    end
+
+    def load_user_data
+      data = FileStore.get(user_data_key)
+      return nil unless data
+      JSON.parse(data)
+    rescue StandardError
+      nil
+    end
   end
 end

data/lib/tastytrade/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tastytrade
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/tastytrade.rb

@@ -14,6 +14,9 @@ require_relative "tastytrade/version"
 require_relative "tastytrade/client"
 require_relative "tastytrade/models"
 require_relative "tastytrade/session"
+require_relative "tastytrade/order"
+require_relative "tastytrade/order_validator"
+require_relative "tastytrade/instruments/equity"
 
 module Tastytrade
   class Error < StandardError; end
@@ -25,6 +28,46 @@ module Tastytrade
   class InvalidCredentialsError < AuthenticationError; end
   class NetworkTimeoutError < Error; end
 
+  # Order errors
+  class OrderError < Error; end
+  class InvalidOrderError < OrderError; end
+  class InsufficientFundsError < OrderError; end
+  class MarketClosedError < OrderError; end
+  class OrderNotCancellableError < OrderError; end
+  class OrderAlreadyFilledError < OrderError; end
+  class OrderNotEditableError < OrderError; end
+  class InsufficientQuantityError < OrderError; end
+
+  # Order validation errors
+
+  # Base class for order validation errors. Contains an array of specific
+  # validation failures that prevented the order from being placed.
+  class OrderValidationError < OrderError
+    # @return [Array<String>] List of validation errors
+    attr_reader :errors
+
+    # @param errors [String, Array<String>] One or more validation error messages
+    def initialize(errors)
+      @errors = Array(errors)
+      super(@errors.join("; "))
+    end
+  end
+
+  # Raised when an order contains an invalid or non-existent symbol
+  class InvalidSymbolError < OrderValidationError; end
+
+  # Raised when an order would exceed available buying power
+  class InsufficientBuyingPowerError < OrderValidationError; end
+
+  # Raised when the account has restrictions preventing the order
+  class AccountRestrictedError < OrderValidationError; end
+
+  # Raised when the order quantity is invalid (zero, negative, or exceeds limits)
+  class InvalidQuantityError < OrderValidationError; end
+
+  # Raised when the order price is invalid (zero, negative, or unreasonable)
+  class InvalidPriceError < OrderValidationError; end
+
   # API URLs
   API_URL = "https://api.tastyworks.com"
   CERT_URL = "https://api.cert.tastyworks.com"

data/spec/exe/tastytrade_spec.rb

@@ -74,7 +74,7 @@ RSpec.describe "tastytrade executable" do
     it "has login command" do
       result = run_command("help", "login")
       expect(result[:status].success?).to be true
-      expect(result[:stdout]).to include("Login to Tastytrade")
+      expect(result[:stdout]).to include("Login to your Tastytrade account")
     end
 
     it "has accounts command" do

data/spec/spec_helper.rb

@@ -11,6 +11,78 @@ end
 require "bundler/setup"
 require "tastytrade"
 require "webmock/rspec"
+require "vcr"
+
+VCR.configure do |config|
+  config.cassette_library_dir = "spec/fixtures/vcr_cassettes"
+  config.hook_into :webmock
+  config.configure_rspec_metadata!
+
+  # Filter out sensitive data
+  config.filter_sensitive_data("<AUTH_TOKEN>") do |interaction|
+    if interaction.request.headers["Authorization"]
+      interaction.request.headers["Authorization"].first
+    end
+  end
+
+  config.filter_sensitive_data("<SESSION_TOKEN>") do |interaction|
+    if interaction.response.headers["Content-Type"] &&
+       interaction.response.headers["Content-Type"].first.include?("application/json")
+      begin
+        body = JSON.parse(interaction.response.body)
+        body.dig("data", "session-token") || body.dig("data", "session_token")
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+
+  config.filter_sensitive_data("<ACCOUNT_NUMBER>") do |interaction|
+    # Filter account numbers from URLs
+    interaction.request.uri.match(%r{/accounts/([^/]+)})&.captures&.first
+  end
+
+  config.filter_sensitive_data("<USERNAME>") do |interaction|
+    if interaction.request.body && interaction.request.body.include?("username")
+      begin
+        body = JSON.parse(interaction.request.body)
+        body["username"]
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+
+  config.filter_sensitive_data("<PASSWORD>") do |interaction|
+    if interaction.request.body && interaction.request.body.include?("password")
+      begin
+        body = JSON.parse(interaction.request.body)
+        body["password"]
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+
+  # Filter personal information from response bodies
+  config.filter_sensitive_data("<EMAIL>") do |interaction|
+    if interaction.response.body
+      begin
+        body = JSON.parse(interaction.response.body)
+        body.dig("data", "email")
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+
+  # Default cassette options
+  config.default_cassette_options = {
+    record: :new_episodes,
+    match_requests_on: [:method, :uri, :body],
+    allow_playback_repeats: true
+  }
+end
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure

data/spec/tastytrade/cli/positions_spec.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tastytrade/cli"
+
+RSpec.describe "Tastytrade::CLI positions command" do
+  let(:cli) { Tastytrade::CLI.new }
+  let(:output) { StringIO.new }
+  let(:error_output) { StringIO.new }
+  let(:mock_session) { instance_double(Tastytrade::Session, authenticated?: true) }
+  let(:mock_account) do
+    instance_double(
+      Tastytrade::Models::Account,
+      account_number: "5WX12345",
+      nickname: "Main Account"
+    )
+  end
+
+  before do
+    # Capture stdout
+    allow($stdout).to receive(:puts) { |msg| output.puts(msg) }
+
+    # Capture stderr more comprehensively
+    original_stderr = $stderr
+    allow($stderr).to receive(:puts) { |msg| error_output.puts(msg) }
+    allow($stderr).to receive(:print) { |msg| error_output.print(msg) }
+    allow($stderr).to receive(:write) { |msg| error_output.write(msg) }
+
+    # Capture Kernel.warn which is used by error/warning helpers
+    allow(cli).to receive(:warn) do |msg|
+      error_output.puts(msg)
+    end
+
+    # Mock CLI internals
+    allow(cli).to receive(:current_session).and_return(mock_session)
+    allow(cli).to receive(:current_account).and_return(mock_account)
+    allow(cli).to receive(:exit)
+    allow(cli).to receive(:options).and_return({})
+  end
+
+  describe "#positions" do
+    context "when not authenticated" do
+      before do
+        allow(cli).to receive(:current_session).and_return(nil)
+      end
+
+      it "requires authentication" do
+        allow(cli).to receive(:exit).with(1).and_raise(SystemExit.new(1))
+
+        expect { cli.positions }.to raise_error(SystemExit)
+        expect(error_output.string).to include("Error: You must be logged in to use this command.")
+      end
+    end
+
+    context "with no positions" do
+      before do
+        allow(mock_account).to receive(:get_positions).and_return([])
+      end
+
+      it "displays warning message" do
+        cli.positions
+        expect(error_output.string).to include("Warning: No positions found")
+      end
+
+      it "displays fetching message" do
+        cli.positions
+        expect(output.string).to include("Fetching positions for account 5WX12345")
+      end
+    end
+
+    context "with positions" do
+      let(:position1) do
+        instance_double(
+          Tastytrade::Models::CurrentPosition,
+          symbol: "AAPL",
+          quantity: BigDecimal("100"),
+          instrument_type: "Equity",
+          average_open_price: BigDecimal("150.00"),
+          close_price: BigDecimal("155.00"),
+          unrealized_pnl: BigDecimal("500.00"),
+          unrealized_pnl_percentage: BigDecimal("3.33"),
+          option?: false,
+          short?: false
+        )
+      end
+
+      let(:position2) do
+        instance_double(
+          Tastytrade::Models::CurrentPosition,
+          symbol: "MSFT",
+          quantity: BigDecimal("50"),
+          instrument_type: "Equity",
+          average_open_price: BigDecimal("300.00"),
+          close_price: BigDecimal("295.00"),
+          unrealized_pnl: BigDecimal("-250.00"),
+          unrealized_pnl_percentage: BigDecimal("-1.67"),
+          option?: false,
+          short?: false
+        )
+      end
+
+      before do
+        allow(mock_account).to receive(:get_positions).and_return([position1, position2])
+      end
+
+      it "displays positions in table format" do
+        cli.positions
+        output_str = output.string
+        expect(output_str).to include("Symbol")
+        expect(output_str).to include("Quantity")
+        expect(output_str).to include("Type")
+        expect(output_str).to include("Avg Price")
+        expect(output_str).to include("Current Price")
+        expect(output_str).to include("P/L")
+        expect(output_str).to include("P/L %")
+      end
+
+      it "displays position data" do
+        cli.positions
+        output_str = output.string
+        expect(output_str).to include("AAPL")
+        expect(output_str).to include("100")
+        expect(output_str).to include("Equity")
+        expect(output_str).to include("$150.00")
+        expect(output_str).to include("$155.00")
+      end
+
+      it "displays summary statistics" do
+        cli.positions
+        output_str = output.string
+        expect(output_str).to include("Summary: 2 positions")
+        expect(output_str).to include("Winners: 1, Losers: 1")
+      end
+    end
+
+    context "with symbol filter" do
+      before do
+        allow(cli).to receive(:options).and_return({ symbol: "AAPL" })
+      end
+
+      it "passes symbol filter to get_positions" do
+        expect(mock_account).to receive(:get_positions).with(
+          mock_session,
+          hash_including(symbol: "AAPL")
+        ).and_return([])
+        cli.positions
+      end
+    end
+
+    context "with underlying symbol filter" do
+      before do
+        allow(cli).to receive(:options).and_return({ underlying_symbol: "SPY" })
+      end
+
+      it "passes underlying symbol filter to get_positions" do
+        expect(mock_account).to receive(:get_positions).with(
+          mock_session,
+          hash_including(underlying_symbol: "SPY")
+        ).and_return([])
+        cli.positions
+      end
+    end
+
+    context "with include_closed option" do
+      before do
+        allow(cli).to receive(:options).and_return({ include_closed: true })
+      end
+
+      it "passes include_closed flag to get_positions" do
+        expect(mock_account).to receive(:get_positions).with(
+          mock_session,
+          hash_including(include_closed: true)
+        ).and_return([])
+        cli.positions
+      end
+    end
+
+    context "with account option" do
+      before do
+        allow(cli).to receive(:options).and_return({ account: "5WX67890" })
+        allow(Tastytrade::Models::Account).to receive(:get).and_return(mock_account)
+      end
+
+      it "fetches the specified account" do
+        expect(Tastytrade::Models::Account).to receive(:get).with(mock_session, "5WX67890")
+        allow(mock_account).to receive(:get_positions).and_return([])
+        cli.positions
+      end
+    end
+
+    context "on API error" do
+      before do
+        allow(mock_account).to receive(:get_positions).and_raise(
+          Tastytrade::Error, "Network error"
+        )
+      end
+
+      it "displays error message" do
+        allow(cli).to receive(:exit).with(1).and_raise(SystemExit.new(1))
+
+        expect { cli.positions }.to raise_error(SystemExit)
+        expect(error_output.string).to include("Error: Failed to fetch positions: Network error")
+      end
+
+      it "exits with status 1" do
+        expect(cli).to receive(:exit).with(1)
+        cli.positions rescue SystemExit
+      end
+    end
+
+    context "with short position" do
+      let(:short_position) do
+        instance_double(
+          Tastytrade::Models::CurrentPosition,
+          symbol: "TSLA",
+          quantity: BigDecimal("50"),
+          instrument_type: "Equity",
+          average_open_price: BigDecimal("200.00"),
+          close_price: BigDecimal("195.00"),
+          unrealized_pnl: BigDecimal("250.00"),
+          unrealized_pnl_percentage: BigDecimal("2.50"),
+          option?: false,
+          short?: true
+        )
+      end
+
+      before do
+        allow(mock_account).to receive(:get_positions).and_return([short_position])
+      end
+
+      it "displays negative quantity for short positions" do
+        cli.positions
+        output_str = output.string
+        expect(output_str).to include("-50")
+      end
+    end
+
+    context "with option position" do
+      let(:option_position) do
+        instance_double(
+          Tastytrade::Models::CurrentPosition,
+          symbol: "AAPL 240119C00150000",
+          display_symbol: "AAPL 150C 1/19",
+          quantity: BigDecimal("5"),
+          instrument_type: "Option",
+          average_open_price: BigDecimal("5.50"),
+          close_price: BigDecimal("7.25"),
+          unrealized_pnl: BigDecimal("875.00"),
+          unrealized_pnl_percentage: BigDecimal("31.82"),
+          option?: true,
+          short?: false
+        )
+      end
+
+      before do
+        allow(mock_account).to receive(:get_positions).and_return([option_position])
+      end
+
+      it "displays formatted option symbol" do
+        cli.positions
+        output_str = output.string
+        # The table may truncate the symbol, so just check for the key parts
+        expect(output_str).to match(/AAPL 150C/)
+      end
+    end
+  end
+end

data/spec/tastytrade/cli_auth_spec.rb

@@ -18,6 +18,8 @@ RSpec.describe "Tastytrade::CLI authentication commands" do
     allow(cli).to receive(:interactive_mode) # Mock interactive mode
     allow(Tastytrade::SessionManager).to receive(:new).and_return(session_manager)
     allow(session_manager).to receive(:save_session).and_return(true)
+    # Stub environment variable login to return nil so tests use interactive login
+    allow(Tastytrade::Session).to receive(:from_environment).and_return(nil)
   end
 
   describe "#login" do
@@ -147,6 +149,9 @@ RSpec.describe "Tastytrade::CLI authentication commands" do
       end
 
       it "saves username to config" do
+        # Allow config.set calls since save_user_session sets multiple values
+        allow(config).to receive(:set)
+
         # The config is set inside SessionManager#save_session
         expect(Tastytrade::SessionManager).to receive(:new).with(
           username: "test@example.com",