tastytrade 0.2.0

data/spec/tastytrade/cli_status_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+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
+  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") }
+
+  before do
+    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")
+  end
+
+  describe "#status" do
+    context "when not authenticated" do
+      before do
+        allow(cli).to receive(:current_session).and_return(nil)
+      end
+
+      it "displays warning about no active session" do
+        expect { cli.status }.to output(/No active session/).to_stderr
+      end
+
+      it "suggests login command" do
+        expect { cli.status }.to output(/Run 'tastytrade login' to authenticate/).to_stdout
+      end
+    end
+
+    context "when authenticated" do
+      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
+      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
+      end
+    end
+
+    context "when authenticated without remember token" 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
+      end
+    end
+
+    context "when authenticated with remember token" do
+      let(:manager) { instance_double(Tastytrade::SessionManager) }
+
+      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
+      end
+    end
+  end
+end

data/spec/tastytrade/client_spec.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Tastytrade::Client do
+  let(:base_url) { "https://api.example.com" }
+  let(:client) { described_class.new(base_url: base_url) }
+
+  describe "#initialize" do
+    it "sets the base URL" do
+      expect(client.base_url).to eq(base_url)
+    end
+  end
+
+  describe "HTTP methods" do
+    let(:path) { "/test" }
+    let(:response_body) { '{"key": "value"}' }
+    let(:parsed_response) { { "key" => "value" } }
+
+    describe "#get" do
+      it "makes a GET request and returns parsed JSON" do
+        stub_request(:get, "#{base_url}#{path}")
+          .to_return(status: 200, body: response_body, headers: { "Content-Type" => "application/json" })
+
+        result = client.get(path)
+        expect(result).to eq(parsed_response)
+      end
+
+      it "includes query parameters" do
+        params = { foo: "bar" }
+        stub_request(:get, "#{base_url}#{path}")
+          .with(query: params)
+          .to_return(status: 200, body: response_body)
+
+        client.get(path, params)
+      end
+    end
+
+    describe "#post" do
+      it "makes a POST request with JSON body" do
+        body = { data: "test" }
+        stub_request(:post, "#{base_url}#{path}")
+          .with(body: body.to_json,
+                headers: { "Content-Type" => "application/json" })
+          .to_return(status: 201, body: response_body)
+
+        result = client.post(path, body)
+        expect(result).to eq(parsed_response)
+      end
+    end
+
+    describe "#put" do
+      it "makes a PUT request with JSON body" do
+        body = { data: "updated" }
+        stub_request(:put, "#{base_url}#{path}")
+          .with(body: body.to_json,
+                headers: { "Content-Type" => "application/json" })
+          .to_return(status: 200, body: response_body)
+
+        result = client.put(path, body)
+        expect(result).to eq(parsed_response)
+      end
+    end
+
+    describe "#delete" do
+      it "makes a DELETE request" do
+        stub_request(:delete, "#{base_url}#{path}")
+          .to_return(status: 204, body: "")
+
+        result = client.delete(path)
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe "error handling" do
+    let(:path) { "/test" }
+
+    it "raises InvalidCredentialsError for 401 response" do
+      stub_request(:get, "#{base_url}#{path}")
+        .to_return(status: 401, body: '{"error": "Unauthorized"}')
+
+      expect { client.get(path) }.to raise_error(Tastytrade::InvalidCredentialsError, /Authentication failed/)
+    end
+
+    it "raises SessionExpiredError for 403 response" do
+      stub_request(:get, "#{base_url}#{path}")
+        .to_return(status: 403, body: '{"error": "Session expired"}')
+
+      expect { client.get(path) }.to raise_error(Tastytrade::SessionExpiredError, /Session expired or invalid/)
+    end
+
+    it "raises error for 404 response" do
+      stub_request(:get, "#{base_url}#{path}")
+        .to_return(status: 404, body: '{"error": "Not found"}')
+
+      expect { client.get(path) }.to raise_error(Tastytrade::Error, /Resource not found/)
+    end
+
+    it "raises error for 500 response" do
+      stub_request(:get, "#{base_url}#{path}")
+        .to_return(status: 500, body: '{"error": "Internal server error"}')
+
+      expect { client.get(path) }.to raise_error(Tastytrade::Error, /Server error/)
+    end
+
+    it "handles invalid JSON response" do
+      stub_request(:get, "#{base_url}#{path}")
+        .to_return(status: 200, body: "invalid json")
+
+      expect { client.get(path) }.to raise_error(Tastytrade::Error, /Invalid JSON response/)
+    end
+
+    it "handles empty response body" do
+      stub_request(:get, "#{base_url}#{path}")
+        .to_return(status: 200, body: "")
+
+      result = client.get(path)
+      expect(result).to be_nil
+    end
+
+    context "with different error message formats" do
+      it "handles 'error' field" do
+        stub_request(:get, "#{base_url}#{path}")
+          .to_return(status: 400, body: '{"error": "Bad request"}')
+
+        expect { client.get(path) }.to raise_error(Tastytrade::Error, /Bad request/)
+      end
+
+      it "handles 'message' field" do
+        stub_request(:get, "#{base_url}#{path}")
+          .to_return(status: 400, body: '{"message": "Invalid input"}')
+
+        expect { client.get(path) }.to raise_error(Tastytrade::Error, /Invalid input/)
+      end
+
+      it "handles 'reason' field" do
+        stub_request(:get, "#{base_url}#{path}")
+          .to_return(status: 400, body: '{"reason": "Missing parameter"}')
+
+        expect { client.get(path) }.to raise_error(Tastytrade::Error, /Missing parameter/)
+      end
+    end
+  end
+
+  describe "retry behavior" do
+    let(:path) { "/test" }
+
+    it "retries on 503 errors" do
+      stub_request(:get, "#{base_url}#{path}")
+        .to_return(status: 503, body: "")
+        .then.to_return(status: 200, body: '{"success": true}')
+
+      result = client.get(path)
+      expect(result).to eq({ "success" => true })
+    end
+
+    it "does not retry on POST requests" do
+      # POST is not in the retry methods list by default
+      stub_request(:post, "#{base_url}#{path}")
+        .to_return(status: 503, body: "")
+        .times(1)
+
+      expect { client.post(path) }.to raise_error(Tastytrade::Error, /Server error/)
+    end
+  end
+
+  describe "timeout handling" do
+    let(:path) { "/test" }
+
+    it "raises NetworkTimeoutError on GET timeout" do
+      stub_request(:get, "#{base_url}#{path}")
+        .to_timeout
+
+      expect { client.get(path) }.to raise_error(Tastytrade::NetworkTimeoutError, /Request timed out/)
+    end
+
+    it "raises NetworkTimeoutError on POST timeout" do
+      stub_request(:post, "#{base_url}#{path}")
+        .to_timeout
+
+      expect { client.post(path) }.to raise_error(Tastytrade::NetworkTimeoutError, /Request timed out/)
+    end
+
+    it "raises NetworkTimeoutError on PUT timeout" do
+      stub_request(:put, "#{base_url}#{path}")
+        .to_timeout
+
+      expect { client.put(path) }.to raise_error(Tastytrade::NetworkTimeoutError, /Request timed out/)
+    end
+
+    it "raises NetworkTimeoutError on DELETE timeout" do
+      stub_request(:delete, "#{base_url}#{path}")
+        .to_timeout
+
+      expect { client.delete(path) }.to raise_error(Tastytrade::NetworkTimeoutError, /Request timed out/)
+    end
+  end
+
+  describe "timeout configuration" do
+    it "accepts custom timeout" do
+      custom_client = described_class.new(base_url: base_url, timeout: 60)
+      expect(custom_client.instance_variable_get(:@timeout)).to eq(60)
+    end
+
+    it "uses default timeout when not specified" do
+      expect(client.instance_variable_get(:@timeout)).to eq(Tastytrade::Client::DEFAULT_TIMEOUT)
+    end
+  end
+end

data/spec/tastytrade/keyring_store_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tastytrade/keyring_store"
+
+RSpec.describe Tastytrade::KeyringStore do
+  let(:mock_backend) { instance_double(Keyring) }
+
+  before do
+    # Reset the backend before each test
+    described_class.instance_variable_set(:@backend, nil)
+    allow(Keyring).to receive(:new).and_return(mock_backend)
+    # Suppress warnings during tests
+    allow(described_class).to receive(:warn)
+  end
+
+  describe ".set" do
+    it "stores a credential successfully" do
+      expect(mock_backend).to receive(:set_password)
+        .with("tastytrade-ruby", "test_key", "test_value")
+
+      expect(described_class.set("test_key", "test_value")).to be true
+    end
+
+    it "returns false for nil key" do
+      expect(mock_backend).not_to receive(:set_password)
+      expect(described_class.set(nil, "value")).to be false
+    end
+
+    it "returns false for nil value" do
+      expect(mock_backend).not_to receive(:set_password)
+      expect(described_class.set("key", nil)).to be false
+    end
+
+    it "handles errors gracefully" do
+      expect(mock_backend).to receive(:set_password)
+        .and_raise(StandardError, "Keyring error")
+
+      expect(described_class.set("key", "value")).to be false
+    end
+
+    it "converts symbols to strings" do
+      expect(mock_backend).to receive(:set_password)
+        .with("tastytrade-ruby", "symbol_key", "value")
+
+      described_class.set(:symbol_key, "value")
+    end
+  end
+
+  describe ".get" do
+    it "retrieves a credential successfully" do
+      expect(mock_backend).to receive(:get_password)
+        .with("tastytrade-ruby", "test_key")
+        .and_return("test_value")
+
+      expect(described_class.get("test_key")).to eq("test_value")
+    end
+
+    it "returns nil for nil key" do
+      expect(mock_backend).not_to receive(:get_password)
+      expect(described_class.get(nil)).to be_nil
+    end
+
+    it "handles errors gracefully" do
+      expect(mock_backend).to receive(:get_password)
+        .and_raise(StandardError, "Keyring error")
+
+      expect(described_class.get("key")).to be_nil
+    end
+
+    it "converts symbols to strings" do
+      expect(mock_backend).to receive(:get_password)
+        .with("tastytrade-ruby", "symbol_key")
+        .and_return("value")
+
+      expect(described_class.get(:symbol_key)).to eq("value")
+    end
+  end
+
+  describe ".delete" do
+    it "deletes a credential successfully" do
+      expect(mock_backend).to receive(:delete_password)
+        .with("tastytrade-ruby", "test_key")
+
+      expect(described_class.delete("test_key")).to be true
+    end
+
+    it "returns false for nil key" do
+      expect(mock_backend).not_to receive(:delete_password)
+      expect(described_class.delete(nil)).to be false
+    end
+
+    it "handles errors gracefully" do
+      expect(mock_backend).to receive(:delete_password)
+        .and_raise(StandardError, "Keyring error")
+
+      expect(described_class.delete("key")).to be false
+    end
+  end
+
+  describe ".available?" do
+    context "when keyring is available" do
+      it "returns true" do
+        expect(described_class.available?).to be true
+      end
+    end
+
+    context "when keyring is not available" do
+      before do
+        allow(Keyring).to receive(:new).and_raise(StandardError, "No backend")
+      end
+
+      it "returns false" do
+        expect(described_class.available?).to be false
+      end
+    end
+
+    context "when backend is nil" do
+      before do
+        allow(Keyring).to receive(:new).and_return(nil)
+      end
+
+      it "returns false" do
+        expect(described_class.available?).to be false
+      end
+    end
+  end
+
+  describe "error messages" do
+    context "when warnings are not suppressed" do
+      before do
+        allow(described_class).to receive(:warn).and_call_original
+      end
+
+      it "warns on set failure" do
+        expect(mock_backend).to receive(:set_password)
+          .and_raise(StandardError, "Set error")
+
+        expect { described_class.set("key", "value") }
+          .to output(/Failed to store credential: Set error/).to_stderr
+      end
+
+      it "warns on get failure" do
+        expect(mock_backend).to receive(:get_password)
+          .and_raise(StandardError, "Get error")
+
+        expect { described_class.get("key") }
+          .to output(/Failed to retrieve credential: Get error/).to_stderr
+      end
+
+      it "warns on delete failure" do
+        expect(mock_backend).to receive(:delete_password)
+          .and_raise(StandardError, "Delete error")
+
+        expect { described_class.delete("key") }
+          .to output(/Failed to delete credential: Delete error/).to_stderr
+      end
+
+      it "warns when keyring is not available" do
+        allow(Keyring).to receive(:new).and_raise(StandardError, "No backend")
+
+        # Force backend initialization
+        expect { described_class.send(:backend) }
+          .to output(/Keyring not available: No backend/).to_stderr
+      end
+    end
+  end
+end