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 GetDailyTest()
{
var parameter = TickerDayParameter.Create("6501", DayPeriod.Create(2021, 2, 1));
var client = new BuffettCodeApiV3Client(mockApiCore);
Assert.IsNotNull(client.GetDaily(parameter, false, true, false));
}
public void ParseCompanyTest()
{
var json = ApiGetResponseBodyParser.Parse(File.ReadAllText(@"TestData/ApiV3Company.json"));
var company = (Company)parser.Parse(DataTypeConfig.Company, json);
Assert.AreEqual(company.Ticker, "2801");
Assert.AreEqual(company.GetDescription("tosyo_33category").JpName, "東証33業種");
Assert.AreEqual(company.GetDescription("url").Unit, "");
Assert.AreEqual(company.GetValue("url"), @"http://www.kikkoman.co.jp/");
Assert.AreEqual(company.GetValue("accounting_standard"), "IFRS");
var supportedQuarterRanges = company.SupportedQuarterRanges;
Assert.AreEqual((uint)2004, supportedQuarterRanges.OndemandTierRange.From.Year);
Assert.AreEqual((uint)1, supportedQuarterRanges.OndemandTierRange.From.Quarter);
Assert.AreEqual((uint)2021, supportedQuarterRanges.OndemandTierRange.To.Year);
Assert.AreEqual((uint)2, supportedQuarterRanges.OndemandTierRange.To.Quarter);
Assert.AreEqual((uint)2016, supportedQuarterRanges.FixedTierRange
.From.Year);
Assert.AreEqual((uint)3, supportedQuarterRanges.FixedTierRange.From.Quarter);
var supportedDailyRanges = company.SupportedDailyRanges;
var today = DayPeriod.Create(DateTime.Today);
Assert.AreEqual(DayPeriod.Create(2016, 11, 15), supportedDailyRanges.FixedTierRange.From);
Assert.AreEqual(today, supportedDailyRanges.FixedTierRange.To);
Assert.AreEqual(DayPeriod.Create(2000, 4, 3), supportedDailyRanges.OndemandTierRange.From);
Assert.AreEqual(today, supportedDailyRanges.FixedTierRange.To);
}
public void EqualsTest()
{
var a = DayPeriod.Create(2020, 1, 1);
var b = DayPeriod.Create(2020, 1, 1);
var c = DayPeriod.Create(2021, 1, 1);
Assert.AreEqual(a, b);
Assert.AreNotEqual(a, c);
}
public void CreateForDayPeriodTest()
{
var from = DayPeriod.Create(2020, 1, 1);
var to = DayPeriod.Create(2020, 1, 2);
var fqRange = PeriodRange <DayPeriod> .Create(from, to);
Assert.AreEqual(from, fqRange.From);
Assert.AreEqual(to, fqRange.To);
Assert.ThrowsException <ValidationError>(() => PeriodRange <DayPeriod> .Create(to, from));
}
public void GetGapDayPeriodTest()
{
var day20200101 = DayPeriod.Create(2020, 1, 1);
var day20200102 = DayPeriod.Create(2020, 1, 2);
var day20210101 = DayPeriod.Create(2021, 1, 1);
Assert.AreEqual(0, ComparablePeriodUtil.GetGap(day20200101, day20200101));
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(day20200101, day20200102));
Assert.AreEqual(366, ComparablePeriodUtil.GetGap(day20200101, day20210101));
}
public void GetRangeTest()
{
var client = new BuffettCodeApiV2Client(mockApiCore);
var ticker = "2345";
var day = DayPeriod.Create(2021, 2, 1);
var fyFq = FiscalQuarterPeriod.Create(2019, 4);
Assert.IsNotNull(client.GetRange(DataTypeConfig.Quarter, TickerPeriodRangeParameter.Create(ticker, fyFq, fyFq), false, true, false));
Assert.ThrowsException <NotSupportedDataTypeException>(() => client.GetRange(DataTypeConfig.Daily, TickerPeriodRangeParameter.Create(ticker, day, day), false, true, false));
}
public void ToApiV3ParametersTest()
{
var ticker = "1234";
var parameter1 = TickerDayParameter.Create(ticker, DayPeriod.Create(2021, 1, 1)).ToApiV3Parameters();
Assert.AreEqual("2021-01-01", parameter1["date"]);
var parameter2 = TickerDayParameter.Create(ticker, LatestDayPeriod.GetInstance()).ToApiV3Parameters();
Assert.AreEqual("latest", parameter2["date"]);
}
public void CompareToTest()
{
var a = DayPeriod.Create(2020, 1, 1);
var b = DayPeriod.Create(2020, 1, 1);
var c = DayPeriod.Create(2021, 1, 1);
var d = DayPeriod.Create(2020, 2, 3);
Assert.AreEqual(0, a.CompareTo(b));
Assert.AreEqual(-1, a.CompareTo(c));
Assert.AreEqual(-1, a.CompareTo(d));
Assert.AreEqual(1, c.CompareTo(d));
}
public void CreateTest()
{
var ticker = "1234";
var period = DayPeriod.Create(2021, 1, 1);
Assert.AreEqual(period, TickerDayParameter.Create(ticker, period).GetPeriod());
Assert.AreEqual(LatestDayPeriod.GetInstance(), TickerDayParameter.Create(ticker, "latest").GetPeriod());
Assert.AreEqual(period, TickerDayParameter.Create(ticker, "2021-01-01").GetPeriod());
// validation error
Assert.ThrowsException <ValidationError>(() => TickerDayParameter.Create("dummy", period));
}
public void CreateTest()
{
uint y = 2011;
uint m = 1;
uint d = 1;
var day = DayPeriod.Create(y, m, d);
Assert.AreEqual((int)y, day.Value.Year);
Assert.AreEqual((int)m, day.Value.Month);
Assert.AreEqual((int)y, day.Value.Year);
}
public void GetHashCodeTest()
{
var a = DayPeriod.Create(2020, 1, 1).GetHashCode();
var b = DayPeriod.Create(2020, 1, 1).GetHashCode();
var c = DayPeriod.Create(2021, 1, 1).GetHashCode();
var d = DayPeriod.Create(2020, 2, 1).GetHashCode();
var e = DayPeriod.Create(2020, 1, 2).GetHashCode();
Assert.AreEqual(a, b);
Assert.AreNotEqual(a, c);
Assert.AreNotEqual(a, d);
Assert.AreNotEqual(a, e);
}
public void SortTest()
{
var a = DayPeriod.Create(2020, 1, 1);
var b = DayPeriod.Create(2021, 1, 1);
var c = DayPeriod.Create(2020, 2, 3);
var sorted = new List <DayPeriod> {
a, b, c
}.OrderBy(_ => _).ToArray();
Assert.AreEqual(a, sorted[0]);
Assert.AreEqual(c, sorted[1]);
Assert.AreEqual(b, sorted[2]);
}
public void GetTest()
{
var ticker = "2345";
var client = new BuffettCodeApiV2Client(mockApiCore);
var day = TickerDayParameter.Create(ticker, DayPeriod.Create(2021, 2, 1));
var fyFq = TickerQuarterParameter.Create(ticker, FiscalQuarterPeriod.Create(2019, 4));
var empty = TickerEmptyPeriodParameter.Create(ticker, Snapshot.GetInstance());
Assert.IsNotNull(client.Get(DataTypeConfig.Indicator, empty, false, true, false));
Assert.IsNotNull(client.Get(DataTypeConfig.Quarter, fyFq, false, true, false));
Assert.IsNotNull(client.Get(DataTypeConfig.Company, empty, false, true, false));
Assert.ThrowsException <NotSupportedDataTypeException>(() => client.Get(DataTypeConfig.Daily, day, false, true, false));
}
public void GetGapTest()
{
// quarter
var fq2020Q1 = FiscalQuarterPeriod.Create(2020, 1);
var fq2020Q2 = FiscalQuarterPeriod.Create(2020, 2);
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(fq2020Q1, (IPeriod)fq2020Q2));
// day
var day20200101 = DayPeriod.Create(2020, 1, 1);
var day20200102 = DayPeriod.Create(2020, 1, 2);
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(day20200101, (IPeriod)day20200102));
}
public void TotalGapTest()
{
// quarter
var fromFqp = FiscalQuarterPeriod.Create(2020, 1);
var toFqp = FiscalQuarterPeriod.Create(2021, 2);
Assert.AreEqual((uint)5, PeriodRange <FiscalQuarterPeriod> .Create(fromFqp, toFqp).TotalGap());
// day
var fromDay = DayPeriod.Create(2016, 1, 1);
var toDay = DayPeriod.Create(2016, 2, 1);
Assert.AreEqual((uint)31, PeriodRange <DayPeriod> .Create(fromDay, toDay).TotalGap());
}
public void SliceDayTest()
{
var from = DayPeriod.Create(2016, 1, 1);
var to = DayPeriod.Create(2016, 2, 1);
var dayRange = PeriodRange <DayPeriod> .Create(from, to);
// size = 1
var chunks = PeriodRange <DayPeriod> .Slice(dayRange, 1).ToArray();
Assert.AreEqual(32, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from, chunks[0].To);
Assert.AreEqual(from.Next(), chunks[1].From);
Assert.AreEqual(to, chunks[31].From);
Assert.AreEqual(to, chunks[31].To);
for (uint i = 0; i < chunks.Length; i++)
{
Assert.AreEqual(0, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
// size = 2
chunks = PeriodRange <DayPeriod> .Slice(dayRange, 2).ToArray();
Assert.AreEqual(16, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from.Next(), chunks[0].To);
Assert.AreEqual(from.Next().Next(), chunks[1].From);
Assert.AreEqual(to, chunks[15].To);
for (uint i = 0; i < chunks.Length; i++)
{
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
// size = 3
chunks = PeriodRange <DayPeriod> .Slice(dayRange, 3).ToArray();
Assert.AreEqual(11, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from.Next().Next(), chunks[0].To);
Assert.AreEqual(from.Next().Next().Next(), chunks[1].From);
Assert.AreEqual(to, chunks[10].To);
for (uint i = 0; i < chunks.Length - 1; i++)
{
Assert.AreEqual(2, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(chunks.Last().From, chunks.Last().To));
}
public static FixedTierRange Parse(IEnumerable <JProperty> jProperties)
{
try
{
var properties = jProperties.ToDictionary(p => p.Name, p => p.Value.ToString());
var oldestQuarter = FiscalQuarterPeriod.Create(properties[PropertyNames.OldestFiscalYear].ToString(), properties[PropertyNames.OldestFiscalQuarter].ToString());
var latestQuarter = FiscalQuarterPeriod.Create(properties[PropertyNames.LatestFiscalYear], properties[PropertyNames.LatestFiscalQuarter]);
var oldestDate = DayPeriod.Create(DateTime.Parse(properties[PropertyNames.OldestDate]));
return(new FixedTierRange(oldestQuarter, latestQuarter, oldestDate));
}
catch (Exception e)
{
throw new ApiResponseParserException($"parse {PropertyNames.FixedTierRange} failed", e);
}
}
public void GetHashCodeTest()
{
var a = TickerDayParameter.Create("1234", "2021-01-01").GetHashCode();
var b = TickerDayParameter.Create("1234", DayPeriod.Create(2021, 1, 1)).GetHashCode();
var c = TickerDayParameter.Create("2345", DayPeriod.Create(2021, 1, 1)).GetHashCode();
var d = TickerDayParameter.Create("1234", DayPeriod.Create(2021, 1, 2)).GetHashCode();
var f = TickerDayParameter.Create("1234", LatestDayPeriod.GetInstance()).GetHashCode();
var g = TickerDayParameter.Create("1234", LatestDayPeriod.GetInstance()).GetHashCode();
var h = TickerDayParameter.Create("2345", LatestDayPeriod.GetInstance()).GetHashCode();
Assert.AreEqual(a, b);
Assert.AreNotEqual(a, c);
Assert.AreNotEqual(a, d);
Assert.AreNotEqual(a, f);
Assert.AreEqual(f, g);
Assert.AreNotEqual(f, h);
}
public void ParseStringCase()
{
var json = new List <JProperty>();
json.Add(new JProperty("oldest_fiscal_year", "2016"));
json.Add(new JProperty("oldest_fiscal_quarter", "1"));
json.Add(new JProperty("latest_fiscal_year", "2020"));
json.Add(new JProperty("latest_fiscal_quarter", "4"));
json.Add(new JProperty("oldest_date", "2016-11-30"));
var fixedTierRange = FixedTierRangeParser.Parse(json);
Assert.AreEqual((uint)2016, fixedTierRange.OldestQuarter.Year);
Assert.AreEqual((uint)1, fixedTierRange.OldestQuarter.Quarter);
Assert.AreEqual((uint)2020, fixedTierRange.LatestQuarter.Year);
Assert.AreEqual((uint)4, fixedTierRange.LatestQuarter.Quarter);
Assert.AreEqual(DayPeriod.Create(2016, 11, 30), fixedTierRange.OldestDate);
Assert.AreEqual(today, fixedTierRange.LatestDate);
}
public void ParseFloatCase()
{
var json = new List <JProperty>();
var oldestDate = DateTime.Today.AddDays(-365 * 5);
json.Add(new JProperty("oldest_fiscal_year", 2016.0));
json.Add(new JProperty("oldest_fiscal_quarter", 1.0));
json.Add(new JProperty("latest_fiscal_year", 2020.0));
json.Add(new JProperty("latest_fiscal_quarter", 4.0));
json.Add(new JProperty("oldest_date", oldestDate.ToString()));
var fixedTierRange = FixedTierRangeParser.Parse(json);
Assert.AreEqual((uint)2016, fixedTierRange.OldestQuarter.Year);
Assert.AreEqual((uint)1, fixedTierRange.OldestQuarter.Quarter);
Assert.AreEqual((uint)2020, fixedTierRange.LatestQuarter.Year);
Assert.AreEqual((uint)4, fixedTierRange.LatestQuarter.Quarter);
Assert.AreEqual(DayPeriod.Create(oldestDate), fixedTierRange.OldestDate);
Assert.AreEqual(today, fixedTierRange.LatestDate);
}
public void CreateGetDailyRequestTest()
{
// use ondemand
var ticker = "6501";
var parameter = TickerDayParameter.Create(ticker, DayPeriod.Create(2021, 1, 1));
var request = BuffettCodeApiV3RequestCreator.CreateGetDailyRequest(parameter, true);
Assert.AreEqual(BuffettCodeApiV3Config.ENDPOINT_ONDEMAND_DAILY, request.EndPoint);
Assert.AreEqual(ticker, request.Parameters["ticker"]);
Assert.AreEqual("2021-01-01", request.Parameters["date"]);
// not use ondemand
request = BuffettCodeApiV3RequestCreator.CreateGetDailyRequest(parameter, false);
Assert.AreEqual(BuffettCodeApiV3Config.ENDPOINT_DAILY, request.EndPoint);
Assert.AreEqual(ticker, request.Parameters["ticker"]);
Assert.AreEqual("2021-01-01", request.Parameters["date"]);
// latest case
request = BuffettCodeApiV3RequestCreator.CreateGetDailyRequest(TickerDayParameter.Create(ticker, LatestDayPeriod.GetInstance()), false);
Assert.AreEqual(BuffettCodeApiV3Config.ENDPOINT_DAILY, request.EndPoint);
Assert.AreEqual(ticker, request.Parameters["ticker"]);
Assert.AreEqual("latest", request.Parameters["date"]);
}
private static Company ParseCompany(
PropertyDictionary properties,
PropertyDescriptionDictionary descriptions)
{
var fixedTierRangeJson = JObject.Parse(properties.Get(PropertyNames.FixedTierRange));
var fixedTierRange = FixedTierRangeParser.Parse(fixedTierRangeJson.Properties());
var oldestFy = uint.Parse(properties.Get(PropertyNames.OldestFiscalYear));
var oldestFq = uint.Parse(properties.Get(PropertyNames.OldestFiscalQuarter));
var latestFy = uint.Parse(properties.Get(PropertyNames.LatestFiscalYear));
var latestFq = uint.Parse(properties.Get(PropertyNames.LatestFiscalQuarter));
var oldestDate = DayPeriod.Parse(properties.Get(PropertyNames.OldestDate));
// use today as latest date
var latestDate = DayPeriod.Create(DateTime.Today);
var fixedTierQuarterRange = PeriodRange <FiscalQuarterPeriod> .Create(fixedTierRange.OldestQuarter, fixedTierRange.LatestQuarter);
var fixedTierDayRange = PeriodRange <DayPeriod> .Create(fixedTierRange.OldestDate, fixedTierRange.LatestDate);
var ondemandPeriodRange = PeriodRange <FiscalQuarterPeriod> .Create(
FiscalQuarterPeriod.Create(oldestFy, oldestFq),
FiscalQuarterPeriod.Create(latestFy, latestFq)
);
var ondemandTierDayRange = PeriodRange <DayPeriod> .Create(oldestDate, latestDate);
return(Company.Create(
properties.Get(PropertyNames.Ticker),
fixedTierQuarterRange,
ondemandPeriodRange,
fixedTierDayRange,
ondemandTierDayRange,
properties,
descriptions
));
}
public void NextTest()
{
var day = DayPeriod.Create(2020, 12, 31);
Assert.AreEqual(day.Next(), DayPeriod.Create(2021, 1, 1));
}
public void ToStringTest()
{
Assert.AreEqual("2020-01-01", DayPeriod.Create(2020, 1, 1).ToString());
}
