public void GetHashCodeTest()
{
var hashCode = RelativeFiscalQuarterPeriod.Create(0, 1).GetHashCode();
Assert.AreEqual((0, 1).GetHashCode(), hashCode);
Assert.AreNotEqual((1, 2).GetHashCode(), hashCode);
}
public void CreateTest()
{
var ticker = "1234";
var latestQuarter = FiscalQuarterPeriod.Create(2020, 2);
// latest
Assert.AreEqual(TickerDayParameter.Create(ticker, LatestDayPeriod.GetInstance()), TickerPeriodParameterCreator.Create(ticker, "latest", null));
// day
Assert.AreEqual(TickerDayParameter.Create(ticker,
DayPeriod.Create(2020, 1, 1)), TickerPeriodParameterCreator.Create(ticker, "2020-01-01", null));
// LYLQ
Assert.AreEqual(TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.Create(0, 0)), TickerPeriodParameterCreator.Create(ticker, "LYLQ", null));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.Create(1, 0)), TickerPeriodParameterCreator.Create(ticker, "LY-1LQ", null));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.Create(0, 2)), TickerPeriodParameterCreator.Create(ticker, "LYLQ-2", null));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.Create(1, 2)), TickerPeriodParameterCreator.Create(ticker, "LY-1LQ-2", null));
// Quarter
Assert.AreEqual(TickerQuarterParameter.Create(ticker, FiscalQuarterPeriod.Create(2020, 1)), TickerPeriodParameterCreator.Create(ticker, "2020Q1", null));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, "2019", "LQ-1", FiscalQuarterPeriod.Create(2019, 1)), TickerPeriodParameterCreator.Create(ticker, "2019LQ-1", latestQuarter));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, "2019", "LQ-2", FiscalQuarterPeriod.Create(2018, 4)), TickerPeriodParameterCreator.Create(ticker, "2019LQ-2", latestQuarter));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, "LY-2", "4", FiscalQuarterPeriod.Create(2018, 4)), TickerPeriodParameterCreator.Create(ticker, "LY-2Q4", latestQuarter));
// others
Assert.ThrowsException <ValidationError>(() => TickerPeriodParameterCreator.Create(ticker, "dummy", null));
}
public void TotalPrevQuartersTest()
{
Assert.AreEqual((uint)1, RelativeFiscalQuarterPeriod.Create(0, 1).TotalPrevQuarters);
Assert.AreEqual((uint)3, RelativeFiscalQuarterPeriod.Create(0, 3).TotalPrevQuarters);
Assert.AreEqual((uint)4, RelativeFiscalQuarterPeriod.Create(1, 0).TotalPrevQuarters);
Assert.AreEqual((uint)5, RelativeFiscalQuarterPeriod.Create(1, 1).TotalPrevQuarters);
Assert.AreEqual((uint)6, RelativeFiscalQuarterPeriod.Create(0, 6).TotalPrevQuarters);
}
public void FiscalQuarterAsStringTest()
{
var period0 = RelativeFiscalQuarterPeriod.Create(0, 0);
Assert.AreEqual("LQ", period0.FiscalQuarterAsString());
var period1 = RelativeFiscalQuarterPeriod.Create(1, 2);
Assert.AreEqual("LQ-2", period1.FiscalQuarterAsString());
}
public void CompareToTest()
{
var period0 = RelativeFiscalQuarterPeriod.Create(0, 1);
var period1 = RelativeFiscalQuarterPeriod.Create(1, 2);
var period2 = RelativeFiscalQuarterPeriod.Create(1, 2);
var period3 = RelativeFiscalQuarterPeriod.Create(0, 6);
Assert.IsTrue(period0.CompareTo(period1) < 0);
Assert.IsTrue(period0.CompareTo(period2) < 0);
Assert.IsTrue(period1.CompareTo(period2) == 0);
Assert.IsTrue(period1.CompareTo(period3) == 0);
}
public void EqualsTest()
{
var a = RelativeFiscalQuarterPeriod.Create(0, 1);
var b = RelativeFiscalQuarterPeriod.Create(1, 2);
var c = RelativeFiscalQuarterPeriod.Create(1, 2);
Assert.IsFalse(a.Equals(b));
Assert.IsFalse(b.Equals(a));
Assert.IsFalse(a.Equals(c));
Assert.IsFalse(a.Equals(null));
Assert.IsTrue(b.Equals(c));
}
public static ITickerPeriodParameter Create(string ticker, string periodParam, FiscalQuarterPeriod latestFiscalQuarterPeriod)
{
if (periodParam.Equals("latest"))
{
return(TickerDayParameter.Create(ticker, LatestDayPeriod.GetInstance()));
}
else if (PeriodRegularExpressionConfig.DayRegex.IsMatch(periodParam))
{
return(TickerDayParameter.Create(ticker, DayPeriod.Parse(periodParam)));
}
else if (PeriodRegularExpressionConfig.FiscalQuarterRegex.IsMatch(periodParam))
{
var period = FiscalQuarterPeriod.Parse(periodParam);
return(TickerQuarterParameter.Create(ticker, period));
}
else if (PeriodRegularExpressionConfig.RelativeFiscalQuarterRegex.IsMatch(periodParam))
{
var period = RelativeFiscalQuarterPeriod.Parse(periodParam);
return(TickerQuarterParameter.Create(ticker, period));
}
else if (PeriodRegularExpressionConfig.BCodeUdfFiscalQuarterInputRegex.IsMatch(periodParam))
{
var match = PeriodRegularExpressionConfig.BCodeUdfFiscalQuarterInputRegex
.Match(periodParam);
var fy = match.Groups["fiscalYear"].Value.Trim();
var fq = match.Groups["fiscalQuarter"].Value.Trim();
if (fy.Contains("LY"))
{
var prevYears = RelativeFiscalQuarterPeriod.ParseRelativeValue("years", match);
if (prevYears > latestFiscalQuarterPeriod.Year)
{
throw new ValidationError($"{prevYears} is bigger than {latestFiscalQuarterPeriod.Year}");
}
var fiscalQuarter = fq.Replace("Q", "");
var period = FiscalQuarterPeriod.Create(latestFiscalQuarterPeriod.Year - prevYears, uint.Parse(fiscalQuarter));
return(TickerQuarterParameter.Create(ticker, fy, fiscalQuarter, period));
}
else if (fq.Contains("LQ"))
{
var prevQuarters = RelativeFiscalQuarterPeriod.ParseRelativeValue("quarters", match);
var period = FiscalQuarterPeriod.Create(uint.Parse(fy), latestFiscalQuarterPeriod.Quarter).Before(0, prevQuarters);
return(TickerQuarterParameter.Create(ticker, fy, fq, period));
}
else
{
throw new ValidationError($"{periodParam} is not supported input format");
}
}
else
{
throw new ValidationError($"{periodParam} is not supported input format");
}
}
public void NextTest()
{
var period = RelativeFiscalQuarterPeriod.Create(0, 2);
Assert.AreEqual(
RelativeFiscalQuarterPeriod.Create(0, 1),
period.Next()
);
Assert.AreEqual(
RelativeFiscalQuarterPeriod.Create(0, 0),
period.Next().Next()
);
Assert.IsNull(period.Next().Next().Next());
}
public void ResolveTest()
{
var quarterDict = new SupportedTierDictionary <FiscalQuarterPeriod>();
var dayDict = new SupportedTierDictionary <DayPeriod>();
quarterDict.Add(company.Ticker, company.SupportedQuarterRanges);
dayDict.Add(company.Ticker, company.SupportedDailyRanges);
var resolver = new PeriodSupportedTierResolver(null, null, quarterDict, dayDict);
// snapshot
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, Snapshot.GetInstance(), false, false));
// relative quarter periods
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, RelativeFiscalQuarterPeriod.CreateLatest(), false, false));
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, RelativeFiscalQuarterPeriod.Create(5, 1), false, false));
Assert.AreEqual(SupportedTier.OndemandTier, resolver.Resolve(ticker, RelativeFiscalQuarterPeriod.Create(5, 2), false, false));
Assert.AreEqual(SupportedTier.OndemandTier, resolver.Resolve(ticker, RelativeFiscalQuarterPeriod.Create(5, 3), false, false));
Assert.AreEqual(SupportedTier.OndemandTier, resolver.Resolve(ticker, RelativeFiscalQuarterPeriod.Create(11, 2), false, false));
Assert.AreEqual(SupportedTier.None, resolver.Resolve(ticker, RelativeFiscalQuarterPeriod.Create(11, 3), false, false));
Assert.AreEqual(SupportedTier.None, resolver.Resolve(ticker, RelativeFiscalQuarterPeriod.Create(11, 4), false, false));
// latest day
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, LatestDayPeriod.GetInstance(), false, false));
// quarter
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, fixedOldestQuarter, false, false));
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, fixedOldestQuarter.Next() as FiscalQuarterPeriod, false, false));
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, fixedLatestQuarter, false, false));
Assert.AreEqual(SupportedTier.OndemandTier, resolver.Resolve(ticker, ondemandOldestQuarter, false, false));
Assert.AreEqual(SupportedTier.OndemandTier, resolver.Resolve(ticker, ondemandOldestQuarter.Next() as FiscalQuarterPeriod, false, false));
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, ondemandLatestQuarter, false, false));
Assert.AreEqual(SupportedTier.None, resolver.Resolve(ticker, ondemandLatestQuarter.Next() as FiscalQuarterPeriod, false, false));
// day
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, ondemandLatestDay, false, false));
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, fixedTierLatestDay, false, false));
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, fixedTierOldestDay, false, false));
Assert.AreEqual(SupportedTier.FixedTier, resolver.Resolve(ticker, fixedTierOldestDay.Next(), false, false));
Assert.AreEqual(SupportedTier.OndemandTier, resolver.Resolve(ticker, fixedTierOldestDay.Prev(), false, false));
Assert.AreEqual(SupportedTier.OndemandTier, resolver.Resolve(ticker, ondemandOldestDay, false, false));
Assert.AreEqual(SupportedTier.OndemandTier, resolver.Resolve(ticker, ondemandOldestDay.Next(), false, false));
Assert.AreEqual(SupportedTier.None, resolver.Resolve(ticker, ondemandOldestDay.Prev(), false, false));
Assert.AreEqual(SupportedTier.None, resolver.Resolve(ticker, fixedTierLatestDay.Next(), false, false));
Assert.AreEqual(SupportedTier.None, resolver.Resolve(ticker, ondemandLatestDay.Next(), false, false));
}
public void ParseTest()
{
var period0 = RelativeFiscalQuarterPeriod.Parse("LYLQ");
Assert.AreEqual(RelativeFiscalQuarterPeriod.Create(0, 0), period0);
var period1 = RelativeFiscalQuarterPeriod.Parse("LY-1LQ");
Assert.AreEqual(RelativeFiscalQuarterPeriod.Create(1, 0), period1);
var period2 = RelativeFiscalQuarterPeriod.Parse("LYLQ-20");
Assert.AreEqual(RelativeFiscalQuarterPeriod.Create(0, 20), period2);
var period3 = RelativeFiscalQuarterPeriod.Parse("LY-10LQ-2");
Assert.AreEqual(RelativeFiscalQuarterPeriod.Create(10, 2), period3);
Assert.ThrowsException <ValidationError>(() => RelativeFiscalQuarterPeriod.Parse("dummy"));
Assert.ThrowsException <ValidationError>(() => RelativeFiscalQuarterPeriod.Parse("LY-0LQ"));
Assert.ThrowsException <ValidationError>(() => RelativeFiscalQuarterPeriod.Parse("LYLQ-0"));
}
private SupportedTier ResolveQuarterPeriod(string ticker, RelativeFiscalQuarterPeriod period, bool isConfigureAwait, bool useCache)
{
if (!quarterDict.Has(ticker))
{
var company = GetCompany(ticker, isConfigureAwait, useCache);
quarterDict.Add(company.Ticker, company.SupportedQuarterRanges);
}
if (period.TotalPrevQuarters <= quarterDict.FixedTierRengeLength(ticker))
{
return(SupportedTier.FixedTier);
}
else if (period.TotalPrevQuarters <= quarterDict.OndemandTierRengeLength(ticker))
{
return(SupportedTier.OndemandTier);
}
else
{
return(SupportedTier.None);
}
}
public void EqualsTest()
{
var a = TickerQuarterParameter.Create("1234", FiscalQuarterPeriod.Create(2020, 1));
var b = TickerQuarterParameter.Create("1234", FiscalQuarterPeriod.Parse("2020Q1"));
var c = TickerQuarterParameter.Create("2345", FiscalQuarterPeriod.Create(2020, 1));
var d = TickerQuarterParameter.Create("1234", FiscalQuarterPeriod.Create(2020, 2));
var e = TickerQuarterParameter.Create("1234", RelativeFiscalQuarterPeriod.Create(1, 2));
var f = TickerQuarterParameter.Create("1234", RelativeFiscalQuarterPeriod.Create(1, 2));
var g = TickerQuarterParameter.Create("1234", RelativeFiscalQuarterPeriod.Create(1, 3));
var i = TickerQuarterParameter.Create("2345", RelativeFiscalQuarterPeriod.Create(1, 2));
var j = TickerQuarterParameter.Create("2345", "2019", "LQ-2", RelativeFiscalQuarterPeriod.Create(1, 2));
Assert.AreEqual(a, b);
Assert.AreNotEqual(a, c);
Assert.AreNotEqual(a, d);
Assert.AreNotEqual(a, e);
Assert.AreEqual(e, f);
Assert.AreNotEqual(e, g);
Assert.AreNotEqual(e, i);
Assert.AreNotEqual(e, g);
Assert.AreNotEqual(e, j);
}
public void CreateTest()
{
var ticker = "1234";
// fiscal quarter period
var quarter = FiscalQuarterPeriod.Create(2020, 1);
Assert.AreEqual("2020Q1",
TickerQuarterParameter.Create(ticker, FiscalQuarterPeriod.Create(2020, 1)).GetPeriod().ToString());
Assert.AreEqual("2020Q1",
TickerQuarterParameter.Create(ticker, "LY-1", "LQ-20", FiscalQuarterPeriod.Create(2020, 1)).GetPeriod().ToString());
Assert.AreEqual("LYLQ",
TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.Create(0, 0)).GetPeriod().ToString());
// validation checks
Assert.ThrowsException <ValidationError>(() => TickerQuarterParameter.Create("dummy", "LY", "LQ", quarter));
Assert.ThrowsException <ValidationError>(() => TickerQuarterParameter.Create(ticker, "ly", "LQ", quarter));
Assert.ThrowsException <ValidationError>(() => TickerQuarterParameter.Create(ticker, "LY", "lq", quarter));
Assert.ThrowsException <ValidationError>(() => TickerQuarterParameter.Create(ticker, "LY", "6", quarter));
}
public ITickerPeriodParameter Build()
{
switch (dataType)
{
case DataTypeConfig.Indicator:
return(TickerEmptyPeriodParameter.Create(ticker, Snapshot.GetInstance()));
case DataTypeConfig.Quarter:
if (string.IsNullOrWhiteSpace(parameter1) && string.IsNullOrWhiteSpace(parameter2))
{
return(TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.CreateLatest()));
}
else
{
return(TickerQuarterParameter.Create(ticker, FiscalQuarterPeriod.Create(parameter1, parameter2)));
}
case DataTypeConfig.Daily:
return(TickerDayParameter.Create(ticker, LatestDayPeriod.GetInstance()));
default:
throw new NotSupportedDataTypeException($"dataType ={dataType} is not supported.");
}
}
public void SortTest()
{
var a = RelativeFiscalQuarterPeriod.Create(0, 1);
var b = RelativeFiscalQuarterPeriod.Create(0, 3);
var c = RelativeFiscalQuarterPeriod.Create(1, 0);
var d = RelativeFiscalQuarterPeriod.Create(1, 1);
var e = RelativeFiscalQuarterPeriod.Create(0, 6);
var random = new Random();
var randomOrdreList = new List <RelativeFiscalQuarterPeriod> {
a, b, c, d, e
}.OrderBy(_ => random.Next());
var sorted = new List <RelativeFiscalQuarterPeriod> {
a, b, c, d, e
}.OrderBy(_ => _).ToArray();
Assert.AreEqual(a, sorted[0]);
Assert.AreEqual(b, sorted[1]);
Assert.AreEqual(c, sorted[2]);
Assert.AreEqual(d, sorted[3]);
Assert.AreEqual(e, sorted[4]);
}
public void ToStringTest()
{
Assert.AreEqual("LYLQ-1", RelativeFiscalQuarterPeriod.Create(0, 1).ToString());
Assert.AreEqual("LY-1LQ-2", RelativeFiscalQuarterPeriod.Create(1, 2).ToString());
}
public static TickerQuarterParameter Create(string ticker, RelativeFiscalQuarterPeriod period) => Create(ticker, period.FiscalYearAsString(), period.FiscalQuarterAsString(), period);
public void CreateLatestTest()
{
Assert.AreEqual(RelativeFiscalQuarterPeriod.Create(0, 0), RelativeFiscalQuarterPeriod.CreateLatest());
}
public void FindAvailableTierTest()
{
var tierResolver = CreatTierResolver();
var helper = new ApiTaskHelper(tierResolver);
// enable ondemand endpoint
// quarter
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, fixedOldestQuarter, true, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, fixedOldestQuarter.Next() as FiscalQuarterPeriod, true, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, fixedLatestQuarter, true, true, true));
Assert.AreEqual(SupportedTier.OndemandTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, ondemandOldestQuarter, true, true, true));
Assert.AreEqual(SupportedTier.OndemandTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, ondemandOldestQuarter.Next() as FiscalQuarterPeriod, true, true, true));
Assert.AreEqual(SupportedTier.OndemandTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, ondemandLatestQuarter, true, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, RelativeFiscalQuarterPeriod.CreateLatest(), true, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, ondemandLatestQuarter.Next() as FiscalQuarterPeriod, true, true, true));
// daily
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, fixedTierOldestDay, true, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, fixedTierOldestDay.Next() as DayPeriod, true, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, fixedTierLatestDay, true, true, true));
Assert.AreEqual(SupportedTier.OndemandTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, ondemandOldestDay, true, true, true));
Assert.AreEqual(SupportedTier.OndemandTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, ondemandOldestDay.Next() as DayPeriod, true, true, true));
Assert.AreEqual(SupportedTier.OndemandTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, ondemandLatestDay, true, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, LatestDayPeriod.GetInstance(), true, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Daily, ticker, ondemandLatestDay.Next() as DayPeriod, true, true, true));
// disabled ondemand endpoint
// quarter
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, fixedOldestQuarter, false, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, fixedOldestQuarter.Next() as FiscalQuarterPeriod, false, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, fixedLatestQuarter, false, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, ondemandOldestQuarter, false, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, ondemandOldestQuarter.Next() as FiscalQuarterPeriod, false, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, ondemandLatestQuarter, false, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, ondemandLatestQuarter.Next() as FiscalQuarterPeriod, false, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Quarter, ticker, RelativeFiscalQuarterPeriod.CreateLatest(), false, true, true));
// daily
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, fixedTierOldestDay, false, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, fixedTierOldestDay.Next() as DayPeriod, false, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, fixedTierLatestDay, false, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Daily, ticker, ondemandLatestDay, false, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Daily, ticker, ondemandLatestDay.Next() as DayPeriod, false, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Daily, ticker, ondemandLatestDay, false, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Daily, ticker, LatestDayPeriod.GetInstance(), false, true, true));
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindAvailableTier(DataTypeConfig.Daily, ticker, ondemandLatestDay.Next() as DayPeriod, false, true, true));
// company is always fixed tier
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Company, ticker, Snapshot.GetInstance(), true, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Company, ticker, Snapshot.GetInstance(), false, true, true));
// indicator is always fixed tier
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Indicator, ticker, Snapshot.GetInstance(), true, true, true));
Assert.AreEqual(SupportedTier.FixedTier, helper.FindAvailableTier(DataTypeConfig.Indicator, ticker, Snapshot.GetInstance(), false, true, true));
}
