tastytrade 0.2.0

data/spec/tastytrade/cli_accounts_spec.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tastytrade/cli"
+require "tty-table"
+
+RSpec.describe "Tastytrade::CLI accounts command" do
+  let(:cli) { Tastytrade::CLI.new }
+  let(:config) { instance_double(Tastytrade::CLIConfig) }
+  let(:session) { instance_double(Tastytrade::Session) }
+  let(:account1) do
+    instance_double(Tastytrade::Models::Account,
+                    account_number: "5WX12345",
+                    nickname: "Main Account",
+                    account_type_name: "Margin")
+  end
+  let(:account2) do
+    instance_double(Tastytrade::Models::Account,
+                    account_number: "5WX67890",
+                    nickname: nil,
+                    account_type_name: "Cash")
+  end
+
+  before do
+    allow(cli).to receive(:config).and_return(config)
+    allow(cli).to receive(:exit) # Prevent actual exit during tests
+    allow(cli).to receive(:current_session).and_return(session)
+    allow(cli).to receive(:authenticated?).and_return(true)
+    allow(config).to receive(:get).with("current_account_number").and_return(nil)
+    allow(config).to receive(:set)
+  end
+
+  describe "#accounts" do
+    context "when not authenticated" do
+      before do
+        allow(cli).to receive(:authenticated?).and_return(false)
+      end
+
+      it "requires authentication" do
+        expect(cli).to receive(:require_authentication!)
+        # Mock the session.get call that happens after authentication check
+        allow(session).to receive(:get).with("/customers/me/accounts/", {}).and_return(
+          { "data" => { "items" => [] } }
+        )
+        cli.accounts
+      end
+    end
+
+    context "with no accounts" do
+      before do
+        allow(Tastytrade::Models::Account).to receive(:get_all).with(session).and_return([])
+      end
+
+      it "displays warning message" do
+        expect { cli.accounts }.to output(/No accounts found/).to_stderr
+      end
+
+      it "displays fetching message" do
+        expect { cli.accounts }.to output(/Fetching accounts/).to_stdout
+      end
+    end
+
+    context "with single account" do
+      before do
+        allow(Tastytrade::Models::Account).to receive(:get_all).with(session).and_return([account1])
+      end
+
+      it "displays account in table format" do
+        expect { cli.accounts }.to output(/5WX12345/).to_stdout
+        expect { cli.accounts }.to output(/Main Account/).to_stdout
+        expect { cli.accounts }.to output(/Margin/).to_stdout
+      end
+
+      it "auto-selects the account" do
+        expect(config).to receive(:set).with("current_account_number", "5WX12345")
+        cli.accounts
+      end
+
+      it "shows using account message" do
+        expect { cli.accounts }.to output(/Using account: 5WX12345/).to_stdout
+      end
+
+      it "shows total accounts" do
+        expect { cli.accounts }.to output(/Total accounts: 1/).to_stdout
+      end
+    end
+
+    context "with multiple accounts" do
+      before do
+        allow(Tastytrade::Models::Account).to receive(:get_all).with(session).and_return([account1, account2])
+      end
+
+      it "displays all accounts in table format" do
+        expect { cli.accounts }.to output(/5WX12345.*Main Account.*Margin/).to_stdout
+        expect { cli.accounts }.to output(/5WX67890.*Cash/).to_stdout
+      end
+
+      it "handles nil nickname" do
+        expect { cli.accounts }.to output(/5WX67890.*-.*Cash/).to_stdout
+      end
+
+      it "prompts to select account" do
+        expect { cli.accounts }.to output(/Use 'tastytrade select' to choose an account/).to_stdout
+      end
+
+      it "shows total accounts" do
+        expect { cli.accounts }.to output(/Total accounts: 2/).to_stdout
+      end
+    end
+
+    context "with current account selected" do
+      before do
+        allow(config).to receive(:get).with("current_account_number").and_return("5WX12345")
+        allow(Tastytrade::Models::Account).to receive(:get_all).with(session).and_return([account1, account2])
+      end
+
+      it "shows indicator for current account" do
+        expect { cli.accounts }.to output(/→.*5WX12345/).to_stdout
+      end
+
+      it "doesn't prompt to select account" do
+        expect { cli.accounts }.not_to output(/Use 'tastytrade select'/).to_stdout
+      end
+    end
+
+    context "with invalid current account" do
+      before do
+        allow(config).to receive(:get).with("current_account_number").and_return("INVALID")
+        allow(Tastytrade::Models::Account).to receive(:get_all).with(session).and_return([account1, account2])
+      end
+
+      it "prompts to select account" do
+        expect { cli.accounts }.to output(/Use 'tastytrade select' to choose an account/).to_stdout
+      end
+    end
+
+    context "on API error" do
+      before do
+        allow(Tastytrade::Models::Account).to receive(:get_all).with(session).and_raise(Tastytrade::Error,
+                                                                                        "Network error")
+      end
+
+      it "displays error message" do
+        expect(cli).to receive(:exit).with(1)
+        expect { cli.accounts }.to output(/Failed to fetch accounts: Network error/).to_stderr
+      end
+
+      it "exits with status 1" do
+        expect(cli).to receive(:exit).with(1)
+        cli.accounts
+      end
+    end
+
+    context "on unexpected error" do
+      before do
+        allow(Tastytrade::Models::Account).to receive(:get_all).with(session).and_raise(StandardError,
+                                                                                        "Unexpected issue")
+      end
+
+      it "displays generic error message" do
+        expect(cli).to receive(:exit).with(1)
+        expect { cli.accounts }.to output(/Unexpected error: Unexpected issue/).to_stderr
+      end
+    end
+  end
+end

data/spec/tastytrade/cli_auth_spec.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tastytrade/cli"
+
+RSpec.describe "Tastytrade::CLI authentication commands" do
+  let(:cli) { Tastytrade::CLI.new }
+  let(:session) { instance_double(Tastytrade::Session) }
+  let(:user) { instance_double(Tastytrade::Models::User, email: "test@example.com") }
+  let(:prompt) { instance_double(TTY::Prompt) }
+  let(:config) { instance_double(Tastytrade::CLIConfig) }
+  let(:session_manager) { instance_double(Tastytrade::SessionManager) }
+
+  before do
+    allow(cli).to receive(:prompt).and_return(prompt)
+    allow(cli).to receive(:config).and_return(config)
+    allow(cli).to receive(:exit) # Prevent actual exit during tests
+    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)
+  end
+
+  describe "#login" do
+    context "with username provided via option" do
+      before do
+        allow(prompt).to receive(:mask).with("Password:").and_return("secret123")
+        allow(Tastytrade::Session).to receive(:new).and_return(session)
+        allow(session).to receive(:login).and_return(session)
+        allow(session).to receive(:user).and_return(user)
+        allow(session).to receive(:session_token).and_return("test_session_token")
+        allow(session).to receive(:remember_token).and_return("test_remember_token")
+        allow(config).to receive(:set)
+      end
+
+      it "uses provided username and prompts for password" do
+        expect(prompt).not_to receive(:ask)
+        expect(prompt).to receive(:mask).with("Password:")
+
+        cli.options = { username: "test@example.com", test: false, remember: false }
+        expect { cli.login }.to output(/Successfully logged in/).to_stdout
+      end
+
+      it "creates session with correct parameters" do
+        expect(Tastytrade::Session).to receive(:new).with(
+          username: "test@example.com",
+          password: "secret123",
+          remember_me: false,
+          is_test: false
+        ).and_return(session)
+
+        cli.options = { username: "test@example.com", test: false, remember: false }
+        cli.login
+      end
+    end
+
+    context "with interactive username prompt" do
+      before do
+        allow(prompt).to receive(:ask).with("Username:").and_return("test@example.com")
+        allow(prompt).to receive(:mask).with("Password:").and_return("secret123")
+        allow(Tastytrade::Session).to receive(:new).and_return(session)
+        allow(session).to receive(:login).and_return(session)
+        allow(session).to receive(:user).and_return(user)
+        allow(session).to receive(:session_token).and_return("test_session_token")
+        allow(session).to receive(:remember_token).and_return("test_remember_token")
+        allow(config).to receive(:set)
+      end
+
+      it "prompts for both username and password" do
+        expect(prompt).to receive(:ask).with("Username:")
+        expect(prompt).to receive(:mask).with("Password:")
+
+        cli.options = { test: false, remember: false }
+        cli.login
+      end
+    end
+
+    context "with test environment" do
+      before do
+        allow(prompt).to receive(:ask).with("Username:").and_return("test@example.com")
+        allow(prompt).to receive(:mask).with("Password:").and_return("secret123")
+        allow(Tastytrade::Session).to receive(:new).and_return(session)
+        allow(session).to receive(:login).and_return(session)
+        allow(session).to receive(:user).and_return(user)
+        allow(session).to receive(:session_token).and_return("test_session_token")
+        allow(session).to receive(:remember_token).and_return("test_remember_token")
+        allow(config).to receive(:set)
+      end
+
+      it "creates session with test flag" do
+        expect(Tastytrade::Session).to receive(:new).with(
+          username: "test@example.com",
+          password: "secret123",
+          remember_me: false,
+          is_test: true
+        ).and_return(session)
+
+        cli.options = { test: true, remember: false }
+        expect { cli.login }.to output(/sandbox environment/).to_stdout
+      end
+
+      it "saves sandbox environment to config" do
+        # The config is set inside SessionManager#save_session
+        expect(Tastytrade::SessionManager).to receive(:new).with(
+          username: "test@example.com",
+          environment: "sandbox"
+        ).and_return(session_manager)
+
+        cli.options = { test: true, remember: false }
+        cli.login
+      end
+    end
+
+    context "with remember option" do
+      before do
+        allow(prompt).to receive(:ask).with("Username:").and_return("test@example.com")
+        allow(prompt).to receive(:mask).with("Password:").and_return("secret123")
+        allow(Tastytrade::Session).to receive(:new).and_return(session)
+        allow(session).to receive(:login).and_return(session)
+        allow(session).to receive(:user).and_return(user)
+        allow(session).to receive(:session_token).and_return("test_session_token")
+        allow(session).to receive(:remember_token).and_return("test_remember_token")
+        allow(config).to receive(:set)
+      end
+
+      it "creates session with remember flag" do
+        expect(Tastytrade::Session).to receive(:new).with(
+          username: "test@example.com",
+          password: "secret123",
+          remember_me: true,
+          is_test: false
+        ).and_return(session)
+
+        cli.options = { test: false, remember: true }
+        cli.login
+      end
+    end
+
+    context "on successful login" do
+      before do
+        allow(prompt).to receive(:ask).with("Username:").and_return("test@example.com")
+        allow(prompt).to receive(:mask).with("Password:").and_return("secret123")
+        allow(Tastytrade::Session).to receive(:new).and_return(session)
+        allow(session).to receive(:login).and_return(session)
+        allow(session).to receive(:user).and_return(user)
+        allow(session).to receive(:session_token).and_return("test_session_token")
+        allow(session).to receive(:remember_token).and_return("test_remember_token")
+      end
+
+      it "saves username to config" do
+        # The config is set inside SessionManager#save_session
+        expect(Tastytrade::SessionManager).to receive(:new).with(
+          username: "test@example.com",
+          environment: "production"
+        ).and_return(session_manager)
+        expect(session_manager).to receive(:save_session).with(
+          session,
+          password: "secret123",
+          remember: false
+        ).and_return(true)
+
+        cli.options = { test: false, remember: false }
+        cli.login
+      end
+
+      it "displays success message with user email" do
+        allow(config).to receive(:set)
+
+        cli.options = { test: false, remember: false }
+        expect { cli.login }.to output(/Successfully logged in as test@example.com/).to_stdout
+      end
+
+      it "enters interactive mode after successful login" do
+        allow(config).to receive(:set)
+        expect(cli).to receive(:interactive_mode)
+
+        cli.options = { test: false, remember: false }
+        cli.login
+      end
+    end
+
+    context "on authentication error" do
+      before do
+        allow(prompt).to receive(:ask).with("Username:").and_return("test@example.com")
+        allow(prompt).to receive(:mask).with("Password:").and_return("wrong")
+        allow(Tastytrade::Session).to receive(:new).and_return(session)
+        allow(session).to receive(:login).and_raise(Tastytrade::Error, "Invalid credentials")
+      end
+
+      it "displays error message" do
+        cli.options = { test: false, remember: false }
+        expect(cli).to receive(:exit).with(1)
+        expect { cli.login }.to output(/Error: Invalid credentials/).to_stderr
+      end
+
+      it "exits with status 1" do
+        cli.options = { test: false, remember: false }
+        expect(cli).to receive(:exit).with(1)
+        cli.login
+      end
+    end
+
+    context "on unexpected error" do
+      before do
+        allow(prompt).to receive(:ask).with("Username:").and_return("test@example.com")
+        allow(prompt).to receive(:mask).with("Password:").and_return("secret123")
+        allow(Tastytrade::Session).to receive(:new).and_raise(StandardError, "Connection timeout")
+      end
+
+      it "displays generic error message" do
+        cli.options = { test: false, remember: false }
+        expect(cli).to receive(:exit).with(1)
+        expect { cli.login }.to output(/Error: Login failed: Connection timeout/).to_stderr
+      end
+    end
+  end
+end

data/spec/tastytrade/cli_config_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tastytrade/cli_config"
+require "tmpdir"
+require "fileutils"
+
+RSpec.describe Tastytrade::CLIConfig do
+  let(:temp_dir) { Dir.mktmpdir }
+  let(:config_dir) { File.join(temp_dir, ".config", "tastytrade") }
+  let(:config_file) { File.join(config_dir, "config.yml") }
+
+  before do
+    # Override the config directory for testing
+    stub_const("Tastytrade::CLIConfig::CONFIG_DIR", config_dir)
+    stub_const("Tastytrade::CLIConfig::CONFIG_FILE", config_file)
+  end
+
+  after do
+    FileUtils.rm_rf(temp_dir)
+  end
+
+  describe "#initialize" do
+    context "when config file doesn't exist" do
+      it "creates config directory" do
+        described_class.new
+        expect(Dir.exist?(config_dir)).to be true
+      end
+
+      it "loads default configuration" do
+        config = described_class.new
+        expect(config.data).to eq(described_class::DEFAULT_CONFIG)
+      end
+    end
+
+    context "when config file exists" do
+      before do
+        FileUtils.mkdir_p(config_dir)
+        File.write(config_file, { "default_account" => "123456" }.to_yaml)
+      end
+
+      it "loads config from file" do
+        config = described_class.new
+        expect(config.get("default_account")).to eq("123456")
+      end
+
+      it "merges with default config" do
+        config = described_class.new
+        expect(config.get("environment")).to eq("production") # from defaults
+        expect(config.get("default_account")).to eq("123456") # from file
+      end
+    end
+
+    context "when config file is corrupted" do
+      before do
+        FileUtils.mkdir_p(config_dir)
+        File.write(config_file, "invalid yaml: [")
+      end
+
+      it "loads default config and warns" do
+        expect { described_class.new }.to output(/Warning: Failed to load config file/).to_stderr
+        config = described_class.new
+        expect(config.data).to eq(described_class::DEFAULT_CONFIG)
+      end
+    end
+  end
+
+  describe "#get" do
+    let(:config) { described_class.new }
+
+    it "returns value for existing key" do
+      expect(config.get("environment")).to eq("production")
+    end
+
+    it "returns nil for non-existent key" do
+      expect(config.get("non_existent")).to be_nil
+    end
+
+    it "accepts symbol keys" do
+      expect(config.get(:environment)).to eq("production")
+    end
+  end
+
+  describe "#set" do
+    let(:config) { described_class.new }
+
+    it "sets a new value" do
+      config.set("test_key", "test_value")
+      expect(config.get("test_key")).to eq("test_value")
+    end
+
+    it "updates existing value" do
+      config.set("environment", "sandbox")
+      expect(config.get("environment")).to eq("sandbox")
+    end
+
+    it "saves to file" do
+      config.set("test_key", "test_value")
+
+      # Load a new config instance to verify persistence
+      new_config = described_class.new
+      expect(new_config.get("test_key")).to eq("test_value")
+    end
+
+    it "accepts symbol keys" do
+      config.set(:test_key, "test_value")
+      expect(config.get("test_key")).to eq("test_value")
+    end
+  end
+
+  describe "#delete" do
+    let(:config) { described_class.new }
+
+    before do
+      config.set("test_key", "test_value")
+    end
+
+    it "removes the key" do
+      config.delete("test_key")
+      expect(config.get("test_key")).to be_nil
+    end
+
+    it "saves changes to file" do
+      config.delete("test_key")
+
+      new_config = described_class.new
+      expect(new_config.get("test_key")).to be_nil
+    end
+  end
+
+  describe "#exists?" do
+    it "returns false when config doesn't exist" do
+      config = described_class.new
+      expect(config.exists?).to be false # file not created until save
+    end
+
+    it "returns true when config exists" do
+      config = described_class.new
+      config.set("test", "value") # This triggers save
+      expect(config.exists?).to be true
+    end
+  end
+
+  describe "#reset!" do
+    let(:config) { described_class.new }
+
+    before do
+      config.set("test_key", "test_value")
+      config.set("environment", "sandbox")
+    end
+
+    it "resets to default values" do
+      config.reset!
+      expect(config.data).to eq(described_class::DEFAULT_CONFIG)
+      expect(config.get("test_key")).to be_nil
+      expect(config.get("environment")).to eq("production")
+    end
+
+    it "saves defaults to file" do
+      config.reset!
+
+      new_config = described_class.new
+      expect(new_config.data).to eq(described_class::DEFAULT_CONFIG)
+    end
+  end
+
+  describe "error handling" do
+    let(:config) { described_class.new }
+
+    context "when save fails" do
+      before do
+        allow(File).to receive(:write).and_raise(StandardError.new("Permission denied"))
+      end
+
+      it "warns but doesn't raise" do
+        expect { config.set("test", "value") }.to output(/Warning: Failed to save config file/).to_stderr
+      end
+    end
+  end
+end