eodhd 0.19.5

data/test/Eodhd/Fundamentals_test.rb

@@ -0,0 +1,163 @@
+# Eodhd/Fundamentals_test.rb
+
+require_relative '../helper'
+
+describe Eodhd::Fundamentals do
+  let(:api_token){ENV.fetch('EODHD_API_TOKEN', '<API_TOKEN>')}
+  let(:fd){Eodhd::Fundamentals.all(api_token: api_token, exchange_code: 'US', symbol: 'AAPL')}
+
+  describe ".all" do
+    it "returns an Eodhd::Fundamentals object" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd).must_be_kind_of(Eodhd::Fundamentals)
+      end
+    end
+
+    it "stores exchange_code and symbol" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.exchange_code).must_equal('US')
+        _(fd.symbol).must_equal('AAPL')
+      end
+    end
+
+    it "returns General as an Eodhd::Fundamentals::General" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.general).must_be_kind_of(Eodhd::Fundamentals::General)
+        _(fd.general.code).must_equal('AAPL')
+        _(fd.general.name).wont_be_nil
+      end
+    end
+
+    it "returns Highlights as an Eodhd::Fundamentals::Highlights" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.highlights).must_be_kind_of(Eodhd::Fundamentals::Highlights)
+        _(fd.highlights.market_capitalization).wont_be_nil
+      end
+    end
+
+    it "returns Valuation as an Eodhd::Fundamentals::Valuation" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.valuation).must_be_kind_of(Eodhd::Fundamentals::Valuation)
+      end
+    end
+
+    it "returns Financials as an Eodhd::Fundamentals::Financials" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.financials).must_be_kind_of(Eodhd::Fundamentals::Financials)
+      end
+    end
+
+    it "returns Financials with typed income_statement, balance_sheet, and cash_flow" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.financials.income_statement).must_be_kind_of(Eodhd::Fundamentals::Financials::IncomeStatement)
+        _(fd.financials.balance_sheet).must_be_kind_of(Eodhd::Fundamentals::Financials::BalanceSheet)
+        _(fd.financials.cash_flow).must_be_kind_of(Eodhd::Fundamentals::Financials::CashFlow)
+      end
+    end
+
+    it "returns quarterly and yearly as sorted arrays of typed entries" do
+      VCR.use_cassette('fundamentals_aapl') do
+        yearly = fd.financials.balance_sheet.yearly
+        _(yearly).must_be_kind_of(Array)
+        _(yearly.first).must_be_kind_of(Eodhd::Fundamentals::Financials::BalanceSheet::Entry)
+        _(fd.financials.balance_sheet.quarterly).must_be_kind_of(Array)
+        dates = yearly.map(&:date)
+        _(dates).must_equal(dates.sort)
+        _(dates.first).must_equal('1985-09-30')
+      end
+    end
+
+    it "resolves interpreted and typo-corrected balance sheet accessors" do
+      VCR.use_cassette('fundamentals_aapl') do
+        latest = fd.financials.balance_sheet.yearly.last
+        _(latest.date).must_equal('2025-09-30')
+        _(latest.total_liabilities).must_equal('285508000000.00')       # totalLiab
+        _(latest.capital_surplus).must_equal('93567852270.00')          # capitalSurpluse (misspelling corrected)
+        _(latest.non_current_assets_other).must_equal('62950000000.00') # nonCurrrentAssetsOther (typo corrected)
+      end
+    end
+
+    it "expands abbreviated income statement accessors" do
+      VCR.use_cassette('fundamentals_aapl') do
+        latest = fd.financials.income_statement.yearly.last
+        _(latest.net_income_from_continuing_operations).must_equal('112010000000.00') # netIncomeFromContinuingOps
+      end
+    end
+
+    it "returns Earnings as an Eodhd::Fundamentals::Earnings" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.earnings).must_be_kind_of(Eodhd::Fundamentals::Earnings)
+      end
+    end
+
+    it "returns Earnings annual, history, and trend as arrays of typed entries" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.earnings.annual.first).must_be_kind_of(Eodhd::Fundamentals::Earnings::AnnualEntry)
+        _(fd.earnings.history.first).must_be_kind_of(Eodhd::Fundamentals::Earnings::HistoryEntry)
+        _(fd.earnings.trend.first).must_be_kind_of(Eodhd::Fundamentals::Earnings::TrendEntry)
+        dates = fd.earnings.annual.map(&:date)
+        _(dates).must_equal(dates.sort)
+      end
+    end
+
+    it "returns Holders institutions and funds as arrays of typed entries" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.holders.institutions).must_be_kind_of(Array)
+        _(fd.holders.funds).must_be_kind_of(Array)
+        institution = fd.holders.institutions.first
+        _(institution).must_be_kind_of(Eodhd::Fundamentals::Holders::Institution)
+        _(institution.name).must_equal('Vanguard Group Inc')
+        _(institution.change_percent).must_equal(1.9191) # change_p
+      end
+    end
+
+    it "returns insider_transactions as a sorted array of InsiderTransaction" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.insider_transactions).must_be_kind_of(Array)
+        _(fd.insider_transactions.first).must_be_kind_of(Eodhd::Fundamentals::InsiderTransaction)
+        dates = fd.insider_transactions.map(&:date)
+        _(dates).must_equal(dates.sort)
+      end
+    end
+
+    it "returns outstanding_shares as OutstandingShares with typed annual and quarterly arrays" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.outstanding_shares).must_be_kind_of(Eodhd::Fundamentals::OutstandingShares)
+        _(fd.outstanding_shares.annual.first).must_be_kind_of(Eodhd::Fundamentals::OutstandingShares::Entry)
+        _(fd.outstanding_shares.quarterly.first).must_be_kind_of(Eodhd::Fundamentals::OutstandingShares::Entry)
+      end
+    end
+
+    it "returns SharesStats as an Eodhd::Fundamentals::SharesStats" do
+      VCR.use_cassette('fundamentals_aapl') do
+        _(fd.shares_stats).must_be_kind_of(Eodhd::Fundamentals::SharesStats)
+        _(fd.shares_stats.shares_outstanding).wont_be_nil
+      end
+    end
+  end
+
+  describe ".all with an ASX symbol" do
+    let(:fd){Eodhd::Fundamentals.all(api_token: api_token, exchange_code: 'AU', symbol: 'CBA')}
+
+    it "wraps a real AU fundamentals payload into the same typed objects" do
+      VCR.use_cassette('fundamentals_cba_au') do
+        _(fd).must_be_kind_of(Eodhd::Fundamentals)
+        _(fd.exchange_code).must_equal('AU')
+        _(fd.symbol).must_equal('CBA')
+        _(fd.general).must_be_kind_of(Eodhd::Fundamentals::General)
+
+        _(fd.financials.balance_sheet).must_be_kind_of(Eodhd::Fundamentals::Financials::BalanceSheet)
+        yearly = fd.financials.balance_sheet.yearly
+        _(yearly).must_be_kind_of(Array)
+        _(yearly).wont_be_empty
+        _(yearly.first).must_be_kind_of(Eodhd::Fundamentals::Financials::BalanceSheet::Entry)
+        dates = yearly.map(&:date)
+        _(dates).must_equal(dates.sort)
+
+        _(fd.holders.institutions).must_be_kind_of(Array)
+        _(fd.insider_transactions).must_be_kind_of(Array)
+        _(fd.outstanding_shares).must_be_kind_of(Eodhd::Fundamentals::OutstandingShares)
+      end
+    end
+  end
+end

data/test/Eodhd/VERSION_test.rb

@@ -0,0 +1,20 @@
+# test/Eodhd/VERSION_test.rb
+
+require_relative '../helper'
+
+describe Eodhd do
+  describe "VERSION" do
+    it "is a string" do
+      _(Eodhd::VERSION).must_be_instance_of String
+    end
+
+    it "is three numbers separated by dots" do
+      _(Eodhd::VERSION).must_match(/\A\d+\.\d+\.\d+\z/)
+    end
+
+    it "matches the newest entry in the CHANGELOG" do
+      changelog = File.read(File.expand_path('../../CHANGELOG', __dir__))
+      _(changelog[/^(\d+\.\d+\.\d+):/, 1]).must_equal Eodhd::VERSION
+    end
+  end
+end

data/test/Eodhd/Validations_test.rb

@@ -0,0 +1,135 @@
+# Eodhd/Validations_test.rb
+
+require_relative '../helper'
+
+class DummyIncludingValidations
+  include Eodhd::Validations
+end
+
+describe Eodhd::Validations do
+  let(:v){DummyIncludingValidations.new}
+
+  describe "#validate_arguments" do
+    it "accepts all valid arguments" do
+      _{v.validate_arguments(
+        exchange_code: 'AU',
+        symbol: 'BHP',
+        period: 'd',
+        from: '2024-01-01',
+        to: '2024-12-31'
+      )}.must_be_silent
+    end
+
+    it "accepts exchange_id as alias for exchange_code" do
+      _{v.validate_arguments(exchange_id: 'AU')}.must_be_silent
+    end
+
+    it "raises ArgumentError for invalid exchange_code" do
+      _{v.validate_arguments(exchange_code: 'au')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for invalid symbol" do
+      _{v.validate_arguments(symbol: 'bad$')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for invalid period" do
+      _{v.validate_arguments(period: 'h')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for invalid from date" do
+      _{v.validate_arguments(from: '2024/01/01')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for invalid to date" do
+      _{v.validate_arguments(to: '2024-02-30')}.must_raise(ArgumentError)
+    end
+
+    it "raises ArgumentError for reversed date range" do
+      _{v.validate_arguments(from: '2024-12-31', to: '2024-01-01')}.must_raise(ArgumentError)
+    end
+
+    it "accepts nil values for all arguments" do
+      _{v.validate_arguments}.must_be_silent
+    end
+  end
+
+  describe "#validate_exchange_code" do
+    it "accepts valid exchange codes" do
+      _{v.validate_exchange_code('AU')}.must_be_silent
+      _{v.validate_exchange_code('XETRA')}.must_be_silent
+    end
+
+    it "rejects invalid exchange codes" do
+      _{v.validate_exchange_code('us')}.must_raise(ArgumentError)
+      _{v.validate_exchange_code('U')}.must_raise(ArgumentError)
+      _{v.validate_exchange_code('TOOLONG')}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_symbol" do
+    it "accepts valid symbols" do
+      _{v.validate_symbol('AAPL')}.must_be_silent
+      _{v.validate_symbol('BRK.B')}.must_be_silent
+      _{v.validate_symbol('RDS-A')}.must_be_silent
+    end
+
+    it "rejects invalid symbols" do
+      _{v.validate_symbol('')}.must_raise(ArgumentError)
+      _{v.validate_symbol(' ')}.must_raise(ArgumentError)
+      _{v.validate_symbol('THIS_SYMBOL_IS_TOO_LONG')}.must_raise(ArgumentError)
+      _{v.validate_symbol('bad$')}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_period" do
+    it "accepts valid periods" do
+      _{v.validate_period('d')}.must_be_silent
+      _{v.validate_period('w')}.must_be_silent
+      _{v.validate_period('m')}.must_be_silent
+    end
+
+    it "rejects invalid periods" do
+      _{v.validate_period('h')}.must_raise(ArgumentError)
+      _{v.validate_period('')}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_interval" do
+    it "accepts valid intervals" do
+      _{v.validate_interval('1m')}.must_be_silent
+      _{v.validate_interval('5m')}.must_be_silent
+      _{v.validate_interval('1h')}.must_be_silent
+      _{v.validate_interval('1d')}.must_be_silent
+    end
+
+    it "rejects invalid intervals" do
+      _{v.validate_interval('2m')}.must_raise(ArgumentError)
+      _{v.validate_interval('invalid')}.must_raise(ArgumentError)
+      _{v.validate_interval('')}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_date" do
+    it "accepts valid date formats and Date objects" do
+      _{v.validate_date('2024-09-30')}.must_be_silent
+      _{v.validate_date(Date.new(2024,9,30))}.must_be_silent
+    end
+
+    it "rejects invalid dates and formats" do
+      _{v.validate_date('2024/09/30')}.must_raise(ArgumentError)
+      _{v.validate_date('2024-02-30')}.must_raise(ArgumentError)
+      _{v.validate_date(12345)}.must_raise(ArgumentError)
+    end
+  end
+
+  describe "#validate_date_range" do
+    it "accepts valid date ranges" do
+      _{v.validate_date_range('2024-01-01','2024-12-31')}.must_be_silent
+      _{v.validate_date_range(Date.new(2024,1,1),Date.new(2024,12,31))}.must_be_silent
+    end
+
+    it "rejects reversed date ranges" do
+      _{v.validate_date_range('2024-12-31','2024-01-01')}.must_raise(ArgumentError)
+    end
+  end
+end

data/test/Eodhd/WebSocketClient_test.rb

@@ -0,0 +1,99 @@
+# Eodhd/WebSocketClient_test.rb
+
+require_relative '../helper'
+
+describe Eodhd::WebSocketClient do
+  let(:api_token){ENV.fetch('EODHD_API_TOKEN', '<API_TOKEN>')}
+  let(:consumer){->(data){}}
+
+  describe "#initialize" do
+    it "accepts array of symbols and formats to comma-separated string" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: ['AAPL', 'MSFT'], consumer: consumer)
+      _(client.symbols).must_equal('AAPL,MSFT')
+    end
+
+    it "accepts string of symbols" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: 'AAPL,MSFT', consumer: consumer)
+      _(client.symbols).must_equal('AAPL,MSFT')
+    end
+  end
+
+  describe "#url" do
+    it "generates correct URL for US trade stream" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: 'AAPL', consumer: consumer)
+      _(client.send(:url)).must_equal("wss://ws.eodhistoricaldata.com/ws/us?api_token=#{api_token}")
+    end
+
+    it "generates correct URL for US quote stream" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us-quote', symbols: 'AAPL', consumer: consumer)
+      _(client.send(:url)).must_equal("wss://ws.eodhistoricaldata.com/ws/us-quote?api_token=#{api_token}")
+    end
+
+    it "generates correct URL for forex stream" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'forex', symbols: 'EURUSD', consumer: consumer)
+      _(client.send(:url)).must_equal("wss://ws.eodhistoricaldata.com/ws/forex?api_token=#{api_token}")
+    end
+
+    it "generates correct URL for crypto stream" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'crypto', symbols: 'BTC-USD', consumer: consumer)
+      _(client.send(:url)).must_equal("wss://ws.eodhistoricaldata.com/ws/crypto?api_token=#{api_token}")
+    end
+  end
+
+  describe "#format_symbols" do
+    it "converts array to comma-separated string" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: ['AAPL', 'MSFT', 'GOOGL'], consumer: consumer)
+      _(client.symbols).must_equal('AAPL,MSFT,GOOGL')
+    end
+
+    it "returns string as-is" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: 'AAPL,MSFT', consumer: consumer)
+      _(client.symbols).must_equal('AAPL,MSFT')
+    end
+  end
+
+  describe "#run" do
+    it "configures Iodine and starts connection" do
+      client = Eodhd::WebSocketClient.new(api_token: api_token, asset_class: 'us', symbols: 'AAPL', consumer: consumer)
+
+      iodine_connect_called = false
+      iodine_start_called = false
+
+      Iodine.stub(:threads=, nil) do
+        Iodine.stub(:connect, ->(opts){iodine_connect_called = true}) do
+          Iodine.stub(:start, ->{iodine_start_called = true}) do
+            client.run
+          end
+        end
+      end
+
+      _(iodine_connect_called).must_equal(true)
+      _(iodine_start_called).must_equal(true)
+    end
+  end
+
+  describe "Handler" do
+    describe "#on_message" do
+      it "parses JSON and calls consumer" do
+        received_data = nil
+        test_consumer = ->(data){received_data = data}
+        handler = Eodhd::WebSocketClient::Handler.new(symbols: 'AAPL', consumer: test_consumer, logger: nil)
+
+        message = '{"symbol":"AAPL","price":150.0}'
+        handler.on_message(nil, message)
+
+        _(received_data).must_be_kind_of(Hash)
+        _(received_data['symbol']).must_equal('AAPL')
+        _(received_data['price']).must_equal(150.0)
+      end
+
+      it "raises Eodhd::Error on invalid JSON" do
+        test_consumer = ->(data){}
+        handler = Eodhd::WebSocketClient::Handler.new(symbols: 'AAPL', consumer: test_consumer, logger: nil)
+
+        invalid_message = '{invalid json'
+        _{handler.on_message(nil, invalid_message)}.must_raise(Eodhd::Error)
+      end
+    end
+  end
+end

data/test/Eodhd_test.rb

@@ -0,0 +1,73 @@
+# Eodhd_test.rb
+
+require_relative "helper"
+
+describe Eodhd do
+  let(:api_token){ENV.fetch('EODHD_API_TOKEN', '<API_TOKEN>')}
+  let(:eodhd){Eodhd.new(api_token: api_token)}
+
+  describe "#exchanges" do
+    it "delegates to Eodhd::Exchange.all" do
+      VCR.use_cassette('eodhd_exchanges') do
+        exchanges = eodhd.exchanges
+        _(exchanges).must_be_kind_of(Array)
+        _(exchanges).wont_be_empty
+        _(exchanges.first).must_be_kind_of(Eodhd::Exchange)
+      end
+    end
+  end
+
+  describe "#exchange_symbols" do
+    it "delegates to Eodhd::ExchangeSymbol.all" do
+      VCR.use_cassette('eodhd_exchange_symbols') do
+        symbols = eodhd.exchange_symbols(exchange_code: 'AU')
+        _(symbols).must_be_kind_of(Array)
+        _(symbols).wont_be_empty
+        _(symbols.first).must_be_kind_of(Eodhd::ExchangeSymbol)
+      end
+    end
+  end
+
+  describe "#eod_data" do
+    it "delegates to Eodhd::EodData.all" do
+      VCR.use_cassette('eodhd_eod_data') do
+        eod_data = eodhd.eod_data(exchange_code: 'AU', symbol: 'BHP', period: 'd')
+        _(eod_data).must_be_kind_of(Array)
+        _(eod_data).wont_be_empty
+        _(eod_data.first).must_be_kind_of(Eodhd::EodData)
+      end
+    end
+  end
+
+  describe "#eod_bulk_last_day" do
+    it "delegates to Eodhd::EodBulkLastDay.all" do
+      VCR.use_cassette('eodhd_eod_bulk_last_day') do
+        bulk_last_day = eodhd.eod_bulk_last_day(exchange_code: 'AU', date: '2024-09-30')
+        _(bulk_last_day).must_be_kind_of(Array)
+        _(bulk_last_day).wont_be_empty
+        _(bulk_last_day.first).must_be_kind_of(Eodhd::EodBulkLastDay)
+      end
+    end
+  end
+
+  describe "#intraday" do
+    it "delegates to Eodhd::Intraday.all" do
+      VCR.use_cassette('eodhd_intraday') do
+        intraday_data = eodhd.intraday(exchange_code: 'US', symbol: 'AAPL', interval: '5m')
+        _(intraday_data).must_be_kind_of(Array)
+        _(intraday_data).wont_be_empty
+        _(intraday_data.first).must_be_kind_of(Eodhd::Intraday)
+      end
+    end
+  end
+
+  describe "#fundamentals" do
+    it "delegates to Eodhd::Fundamentals.all" do
+      VCR.use_cassette('eodhd_fundamentals') do
+        fundamental_data = eodhd.fundamentals(exchange_code: 'US', symbol: 'AAPL')
+        _(fundamental_data).must_be_kind_of(Eodhd::Fundamentals)
+        _(fundamental_data.general).must_be_kind_of(Eodhd::Fundamentals::General)
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+# helper.rb
+
+require 'minitest/autorun'
+require 'minitest/mock'
+require 'minitest/spec'
+require 'minitest-spec-context'
+require 'vcr'
+require 'webmock/minitest'
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require 'Eodhd'
+
+VCR.configure do |config|
+  config.cassette_library_dir = File.expand_path('./fixtures/vcr_cassettes', __dir__)
+  config.hook_into :webmock
+  config.filter_sensitive_data('<API_TOKEN>'){ENV['EODHD_API_TOKEN']}
+end