tests/testthat/test-dsws-timeSeriesRequest.R
In CharlesCara/DatastreamDSWS2R: Provides a Link Between the 'LSEG Datastream' System and R
##############################################################################################
context("classConstructor.R : test of timeSeriesRequest method")
suppressWarnings(suppressPackageStartupMessages(require(xts)))
testDataFolder <- file.path(testthat::test_path(), "testData")
##############################################################################################
test_that("test of simple timeseries request with relative dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
#Load the response rather than hit server
mydsws$jsonResponseLoadFile <- file.path(testDataFolder, "test-dsws-timeSeriesRequest-test01.json")
xtsData <- mydsws$timeSeriesRequest(instrument = "MKS",
datatype = "MV",
startDate = "-30D",
endDate = "-0D",
frequency = "D")
expect_is(xtsData, "xts")
expect_equal(colnames(xtsData), "MKS")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of two stock timeseries request with relative dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
#Load the response rather than hit server
mydsws$jsonResponseLoadFile <- file.path(testDataFolder, "test-dsws-timeSeriesRequest-test02.json")
xtsData <- mydsws$timeSeriesRequest(instrument = c("MKS","RIO"),
datatype = "MV",
startDate = "-30D",
endDate = "-0D",
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of simple timeseries request with absolute dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = "MKS",
datatype = "MV",
startDate = as.Date("2014-10-31"),
endDate = as.Date("2014-11-15"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of two stock timeseries request with absolute dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("MKS","RIO"),
datatype = "MV",
startDate = as.Date("2014-10-31"),
endDate = as.Date("2014-11-15"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#######################################################################################
test_that("test of the instrument being an expression with economic data", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = "PCH#(USCONPRCF,12M)",
datatype = "",
startDate = as.Date("31/12/1960", "%d/%m/%Y"),
endDate = as.Date("31/12/2014", "%d/%m/%Y"),
frequency = "M")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#######################################################################################
test_that("test that no warnings are produce", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
expect_silent({
xtsData <- mydsws$timeSeriesRequest(instrument = c("MSACWF$(RI)/MLGALML(RI)",
"TOTMKUS(RI)/BMUS10Y(RI)"),
datatype = "NAME",
startDate = as.Date("2022-04-27"),
endDate = as.Date("2022-04-27"),
frequency = "D")
})
expect_is(xtsData, "xts")
expect_equal(nrow(xtsData), 0)
expect_equal(ncol(xtsData), 2)
rm(mydsws, xtsData)
})
#######################################################################################
test_that("test of the instrument being an expression with economic data but call with wrong periodicity", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = "PCH#(USCONPRCF,12M)",
datatype = "",
startDate = as.Date("31/12/1960", "%d/%m/%Y"),
endDate = as.Date("31/12/2014", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################
test_that("test of three stock request", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("SAB", "RIO", "MKS"),
datatype = "P",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date("31/12/2014", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of multi stock timeseries request with an expression as the datatype", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("SAB", "RIO", "MKS"),
expression = "PCH#(XXXX,5D)",
startDate = as.Date("31/10/2015", "%d/%m/%Y"),
endDate = as.Date("15/11/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#############################################################
test_that("test of download worldscope data - this data is numeric", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("@AAPL"),
expression = "XXXX(WC01001A)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date('24/01/2012', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
myValues <- zoo::coredata(xtsData)
colnames(myValues) <- NULL
expect_equal(myValues[1:2,1], c(28237000, NA) )
rm(mydsws, xtsData)
})
#############################################################
test_that("test of lowercase RIC Codes", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("<WAFGn.DE>"),
expression = "XXXX",
startDate = as.Date("31/10/2016", "%d/%m/%Y"),
endDate = as.Date('24/11/2016', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
myValues <- zoo::coredata(xtsData)
colnames(myValues) <- NULL
expect_equal(myValues[1:2,1], c(32.770, 32.000) )
rm(mydsws, xtsData)
})
#############################################################
test_that("test of download worldscope data - this data is Dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("@AAPL"),
expression = "XXXX(WC05905A)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date('24/01/2012', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
myValues <- zoo::coredata(xtsData)
colnames(myValues) <- NULL
expect_is(myValues[1,1], "character")
expect_equal(myValues[1:2,1], c("2011-10-18", NA) ) # Date to be decoded
rm(mydsws, xtsData)
})
#############################################################
test_that("test of download worldscope data for multiple stocks", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("@AAPL", "MKS"),
expression = "XXXX(WC05905A)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date('24/01/2012', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#############################################################
test_that("test of Datastream expression eg 045E(XXXX)", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("@AAPL", "MKS"),
expression = "045E(XXXX)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date('24/01/2012', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#############################################################
test_that("test of ISIN code and expression that was not being returned", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
mydsws$setLogging(3)
xtsData <- mydsws$timeSeriesRequest(instrument = c("JP3111200006","JP3802400006"),
expression = "(XXXX(SAL1FD12)/XXXX(SAL1TR12))-1.00",
startDate = as.Date("1996-01-01"),
endDate = as.Date("2016-01-20"),
frequency = "M")
expect_is(xtsData, "xts")
expect_equal(ncol(xtsData), 2L)
rm(mydsws, xtsData)
})
#############################################################
#
# test_that("test of selecting stocks via ISIN codes with missing (NA) codes and expressions", {
# if (is.null(options()$Datastream.Username)) {
# skip("Username not available")
# }
# skip_on_cran()
#
# mydsws <- dsws$new()
# xtsData <- mydsws$timeSeriesRequest(instrument = c("NO0010716582",NA,"SE0005999836",NA,"BMG454221059"),
# datatype = "P",
# startDate = as.Date("01/06/2015", "%d/%m/%Y"),
# endDate = as.Date("01/08/2015", "%d/%m/%Y"),
# frequency = "D")
#
# expect_is(xtsData, "xts")
# expect_equal(ncol(xts), 5L)
#
# rm(mydsws, xtsData)
#
# })
#############################################################
test_that("test of selecting stocks via ISIN codes with missing (NA) codes and expressions", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("NO0010716582",NA,"SE0005999836",NA,"BMG454221059"),
expression = "(XXXX(EPS1FD12)/XXXX(EPS1TR12))-1.00",
startDate = as.Date("01/06/2015", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
expect_equal(ncol(xtsData), 5L)
rm(mydsws, xtsData)
})
#############################################################
test_that("test of selecting stocks via ISIN codes with missing (NA) codes ", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
DSCodes <- c("JP3735400008", NA, "JP3305990008", "JP3117700009")
startDate <- as.Date("1994-12-02")
endDate <- as.Date("2018-01-23")
mydsws <- dsws$new()
xtsRepDates <- mydsws$timeSeriesRequest(instrument = DSCodes,
expression = "XXXX(WC05905A)",
startDate = startDate,
endDate = endDate,
frequency = "D",
format = "ByInstrument")
naRepDates <- xtsRepDates[ , 2]
expect_false(FALSE %in% is.na(naRepDates))
})
#############################################################
test_that("test of selecting stocks via ISIN codes with the first code missing and expressions", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c(NA,"NO0010716582","SE0005999836",NA,"BMG454221059"),
expression = "(XXXX(EPS1FD12)/XXXX(EPS1TR12))-1.00",
startDate = as.Date("01/06/2015", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
expect_equal(ncol(xtsData), 5L)
rm(mydsws, xtsData)
})
#############################################################
test_that("further test of missing stocks ", {
# In this test, nothing is returned from Datastream for the third stock. My thought is that
# the correct response should be an xts with a column per instrument
# and a single row (dated endDate) that has NA's in it.
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("CA91911K1021","US8552441094","VEV0019410A9",
"US5007541064","US4385161066"),
expression = "XXXX(BPS1TR12)/XXXX",
startDate = as.Date("2016-01-30"),
endDate = as.Date("2016-02-01"),
frequency = "D")
expect_is(xtsData, "xts")
expect_equal(ncol(xtsData), 5L)
expect_equal(nrow(xtsData), 2L)
expect_true(TRUE %in% is.na(xtsData[1,]))
rm(mydsws, xtsData)
})
#############################################################
test_that("test of Japanese ISIN with PE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("JP3677200002"),
expression = "XXXX(PE)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of ISIN returns Failure, status code 2, message $$\"ER\", 0904, NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("CA54042L1004"),
expression = "XXXX(PE)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
# This is a mixture of NO DATA AVAILABLE and valid data
#
test_that("test of ISIN returns mixture of NO DATA AVAILABLE and valid data", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("CA54042L1004", "JP3677200002"),
expression = "XXXX(PE)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
# This is a test of chunked requests - first make an unchunked one, and then a chunked one
#
test_that("test of chunked timeSeriesRequests with a datatype", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
symbolList <- mydsws$listRequest(instrument = "LFTSE100",
datatype = "MNEM",
requestDate = "0D")
# Get the unchunked data
xtsTestData <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
datatype = "PE",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsTestData, "xts")
# Get the same data with chunking
rm(mydsws)
mydsws <- dsws$new()
mydsws$chunkLimit <- 25L
xtsDataChunked <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
datatype = "PE",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsDataChunked, "xts")
expect_identical(xtsTestData, xtsDataChunked)
rm(mydsws, xtsTestData, xtsDataChunked, symbolList)
})
##############################################################################################
# This is a test of chunked requests - first make an unchunked one, and then a chunked one
#
test_that("test of chunked timeSeriesRequests with an expression", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
symbolList <- mydsws$listRequest(instrument = "LFTSE100",
datatype = "MNEM",
requestDate = "0D")
# Get the unchunked data
xtsTestData <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
expression = "XXXX(PE)",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsTestData, "xts")
# Get the same data with chunking
rm(mydsws)
mydsws <- dsws$new()
mydsws$chunkLimit <- 25L
xtsDataChunked <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
expression = "XXXX(PE)",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsDataChunked, "xts")
expect_identical(xtsTestData, xtsDataChunked)
rm(mydsws, xtsTestData, xtsDataChunked, symbolList)
})
##############################################################################################
# This is a test of setting chunkLimit via options()
#
test_that("test of setting chunkLimit via options()", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
myChunkLimit <- 123L
options(Datastream.ChunkLimit = myChunkLimit)
mydsws <- dsws$new()
expect_equal(mydsws$chunkLimit, myChunkLimit)
rm(mydsws, myChunkLimit)
options(Datastream.ChunkLimit = NULL)
})
##############################################################################################
# This is a test that if a chunk returns all NA it does not 'poison' the other chunks
#
test_that("test of single chunk returning NA", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
endDate = as.Date("2019-04-26")
expression = "HIDE#(XXXX(NERI0YR))"
frequency = "D"
startDate = as.Date("2019-04-26")
stocks <- readRDS(file.path(testDataFolder, "Europe600Codes.rds"))
mydsws <- dsws$new()
#mydsws$logging <- 60L
myDF <- mydsws$timeSeriesRequest(instrument = stocks,
expression = expression,
startDate = startDate,
endDate = endDate,
frequency = frequency)
expect_true(sum(!is.na(myDF)) > 0)
})
##############################################################################################
# This is a test of chunked requests - This is test that large requests strings are chunked correctly
#
test_that("test of chunking timeSeriesRequests due to request string length", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
symbolList <- mydsws$listRequest(instrument = "LFTSE100",
datatype = "MNEM",
requestDate = "0D")
# Get the unchunked data
xtsTestData <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
expression = "XXXX(PE)",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsTestData, "xts")
# Get the same data with chunking
rm(mydsws)
mydsws <- dsws$new()
mydsws$requestStringLimit <- 300L
xtsDataChunked <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
expression = "XXXX(PE)",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsDataChunked, "xts")
expect_identical(xtsTestData, xtsDataChunked)
rm(mydsws, xtsTestData, xtsDataChunked, symbolList)
})
##############################################################################################
# This is a test of named instruments requests
#
test_that("test of named instruments, datatypes and expressions", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
myIns <- c("@AAPL", "MKS")
names(myIns) <- c("a", "b")
myExp <- "XXXX(P)"
names(myExp) <- "c"
myDt <- "P"
names(myDt) <- "d"
# Expect
expect_silent(xtsTestData <- mydsws$timeSeriesRequest(instrument = myIns,
expression = myExp,
startDate = as.Date("2016-01-01"),
endDate = as.Date("2016-01-10"),
frequency = "D"))
expect_is(xtsTestData, "xts")
expect_true(nrow(xtsTestData) > 1)
expect_silent(xtsTestData <- mydsws$timeSeriesRequest(instrument = myIns,
datatype = myDt,
startDate = as.Date("2016-01-01"),
endDate = as.Date("2016-01-10"),
frequency = "D"))
expect_is(xtsTestData, "xts")
expect_true(nrow(xtsTestData) > 1)
rm(mydsws, myIns, myExp, myDt, xtsTestData)
})
##############################################################################################
# This is a test of chunked requests - This is test that large requests strings are chunked correctly
#
test_that("test of chunking timeSeriesRequests due to request string length", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
symbolList <- readRDS(file.path(testDataFolder, "G100DSCodes.rds"))
# Get the unchunked data
xtsTestData <- mydsws$timeSeriesRequest(instrument = symbolList,
expression = "XXXX(DWND)/XXXX(DWSE)*100.00",
startDate = as.Date("1996-01-01"),
endDate = as.Date("2016-01-10"),
frequency = "W")
expect_is(xtsTestData, "xts")
expect_true(ncol(xtsTestData) == 426)
expect_true(nrow(xtsTestData) == 1045)
rm(mydsws, xtsTestData, symbolList)
})
##############################################################################################
# This is a test of handling mainframe timeouts
#
test_that("test of handling mainframe timeouts", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
mydsws$jsonResponseLoadFile <- file.path(testDataFolder, "TimeoutResponseFull.json")
# Get the unchunked data
instCodes <- c("PCH#(US88033G4073(EPS1TR12),3Y)/100.000", "PCH#(US87612E1064(EPS1TR12),3Y)/100.000",
"PCH#(US87901J1051(EPS1TR12),3Y)/100.000", "PCH#(US8723751009(EPS1TR12),3Y)/100.000",
"PCH#(US8794338298(EPS1TR12),3Y)/100.000", "PCH#(US8718291078(EPS1TR12),3Y)/100.000",
"PCH#(US8636671013(EPS1TR12),3Y)/100.000", "PCH#(US8711301007(EPS1TR12),3Y)/100.000",
"PCH#(US8581222036(EPS1TR12),3Y)/100.000", "PCH#(US7865142084(EPS1TR12),3Y)/100.000",
"PCH#(US8545021011(EPS1TR12),3Y)/100.000", "PCH#(US8685361037(EPS1TR12),3Y)/100.000",
"PCH#(US8574771031(EPS1TR12),3Y)/100.000", "PCH#(US7908491035(EPS1TR12),3Y)/100.000",
"PCH#(US8679141031(EPS1TR12),3Y)/100.000", "PCH#(US8110544025(EPS1TR12),3Y)/100.000",
"PCH#(US8550301027(EPS1TR12),3Y)/100.000", "PCH#(US8354951027(EPS1TR12),3Y)/100.000",
"PCH#(US8425871071(EPS1TR12),3Y)/100.000", "PCH#(US87161C5013(EPS1TR12),3Y)/100.000",
"PCH#(US78442P1066(EPS1TR12),3Y)/100.000", "PCH#(AN8068571086(EPS1TR12),3Y)/100.000",
"PCH#(US8265521018(EPS1TR12),3Y)/100.000", "PCH#(US8202861022(EPS1TR12),3Y)/100.000",
"PCH#(US8243481061(EPS1TR12),3Y)/100.000", "PCH#(US8066051017(EPS1TR12),3Y)/100.000",
"PCH#(US8270561025(EPS1TR12),3Y)/100.000", "PCH#(US8175651046(EPS1TR12),3Y)/100.000",
"PCH#(US8085131055(EPS1TR12),3Y)/100.000", "PCH#(US80589M1027(EPS1TR12),3Y)/100.000",
"PCH#(US7864291007(EPS1TR12),3Y)/100.000", "PCH#(US7551115071(EPS1TR12),3Y)/100.000",
"PCH#(US7504381036(EPS1TR12),3Y)/100.000", "PCH#(US2578671016(EPS1TR12),3Y)/100.000",
"PCH#(US7753711073(EPS1TR12),3Y)/100.000", "PCH#(US7617631012(EPS1TR12),3Y)/100.000",
"PCH#(US7591EP1005(EPS1TR12),3Y)/100.000", "PCH#(US7616951056(EPS1TR12),3Y)/100.000",
"PCH#(US0019201070(EPS1TR12),3Y)/100.000", "PCH#(US7581101000(EPS1TR12),3Y)/100.000",
"PCH#(US7512773026(EPS1TR12),3Y)/100.000", "PCH#(US7677541044(EPS1TR12),3Y)/100.000",
"PCH#(US7835491082(EPS1TR12),3Y)/100.000", "PCH#(US7475251036(EPS1TR12),3Y)/100.000",
"PCH#(US74005P1049(EPS1TR12),3Y)/100.000", "PCH#(US7310951055(EPS1TR12),3Y)/100.000",
"PCH#(US6951141083(EPS1TR12),3Y)/100.000", "PCH#(US69351T1060(EPS1TR12),3Y)/100.000",
"PCH#(US6935061076(EPS1TR12),3Y)/100.000")
xtsTestData <- mydsws$timeSeriesRequest(instrument = instCodes,
expression = "",
startDate = as.Date("2017-02-01"),
endDate = as.Date("2017-03-03"),
frequency = "D")
expect_is(xtsTestData, "xts")
expect_true(ncol(xtsTestData) == 49)
expect_true(nrow(xtsTestData) == 23)
rm(mydsws, xtsTestData, instCodes)
})
##############################################################################################
# This is a test of that if a single timeseries returns $$ER: 0904,NO DATA AVAILABLE and no dates
# the dsws returns a zero row xts.
# Issue # 4
# json response of server stored in testData/test-dsws-timeSeriesRequest-test04.json
#
test_that(" test of that if a single timeseries returns $$ER: 0904,NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
# Get the unchunked data
xtsActData <- mydsws$timeSeriesRequest(instrument = "KO:SGL",
datatype = "AX",
startDate = "2018-05-07",
endDate = "2018-05-09",
frequency = "D")
expect_is(xtsActData, "xts")
expect_true(ncol(xtsActData) == 1)
expect_true(nrow(xtsActData) == 0)
rm(mydsws, xtsActData)
})
##############################################################################################
# This is a test of that if a we request two timeseries and the first returns $$ER: 0904,NO DATA AVAILABLE
# we get then dsws returns an xts with rows.
# Issue # 4
#
test_that("equest two timeseries and the first returns $$ER: 0904,NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
# Get the unchunked data
xtsActData <- mydsws$timeSeriesRequest(instrument = c("III", "KO:SGL"),
datatype = "AX",
startDate = "2018-05-03",
endDate = "2018-05-07",
frequency = "D")
expect_is(xtsActData, "xts")
expect_true(ncol(xtsActData) == 2)
expect_true(nrow(xtsActData) == 3)
rm(mydsws, xtsActData)
})
##############################################################################################
# This is a test of that if a we request two timeseries and the second returns $$ER: 0904,NO DATA AVAILABLE
# we get then dsws returns an xts with rows.
# Issue # 4
#
test_that("test of that if a we request two timeseries and the second returns $$ER: 0904,NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
# Get the unchunked data
xtsActData <- mydsws$timeSeriesRequest(instrument = c("KO:SGL", "III"),
datatype = "AX",
startDate = "2018-05-03",
endDate = "2018-05-07",
frequency = "D")
expect_is(xtsActData, "xts")
expect_true(ncol(xtsActData) == 2)
expect_true(nrow(xtsActData) == 3)
rm(mydsws, xtsActData)
})
##############################################################################################
# This is a test of that if a we request two timeseries and both return $$ER: 0904,NO DATA AVAILABLE
# we get then dsws returns an xts with zero rows.
# Issue # 4
#
test_that(" test of that if a single timeseries returns $$ER: 0904,NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
# Get the unchunked data
xtsActData <- mydsws$timeSeriesRequest(instrument = c("III", "KO:SGL"),
datatype = "AX",
startDate = "2018-05-07",
endDate = "2018-05-09",
frequency = "D")
expect_is(xtsActData, "xts")
expect_true(ncol(xtsActData) == 2)
expect_true(nrow(xtsActData) == 0)
rm(mydsws, xtsActData)
})
CharlesCara/DatastreamDSWS2R documentation built on Jan. 31, 2024, 1 a.m.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
##############################################################################################
context("classConstructor.R : test of timeSeriesRequest method")
suppressWarnings(suppressPackageStartupMessages(require(xts)))
testDataFolder <- file.path(testthat::test_path(), "testData")
##############################################################################################
test_that("test of simple timeseries request with relative dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
#Load the response rather than hit server
mydsws$jsonResponseLoadFile <- file.path(testDataFolder, "test-dsws-timeSeriesRequest-test01.json")
xtsData <- mydsws$timeSeriesRequest(instrument = "MKS",
datatype = "MV",
startDate = "-30D",
endDate = "-0D",
frequency = "D")
expect_is(xtsData, "xts")
expect_equal(colnames(xtsData), "MKS")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of two stock timeseries request with relative dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
#Load the response rather than hit server
mydsws$jsonResponseLoadFile <- file.path(testDataFolder, "test-dsws-timeSeriesRequest-test02.json")
xtsData <- mydsws$timeSeriesRequest(instrument = c("MKS","RIO"),
datatype = "MV",
startDate = "-30D",
endDate = "-0D",
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of simple timeseries request with absolute dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = "MKS",
datatype = "MV",
startDate = as.Date("2014-10-31"),
endDate = as.Date("2014-11-15"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of two stock timeseries request with absolute dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("MKS","RIO"),
datatype = "MV",
startDate = as.Date("2014-10-31"),
endDate = as.Date("2014-11-15"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#######################################################################################
test_that("test of the instrument being an expression with economic data", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = "PCH#(USCONPRCF,12M)",
datatype = "",
startDate = as.Date("31/12/1960", "%d/%m/%Y"),
endDate = as.Date("31/12/2014", "%d/%m/%Y"),
frequency = "M")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#######################################################################################
test_that("test that no warnings are produce", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
expect_silent({
xtsData <- mydsws$timeSeriesRequest(instrument = c("MSACWF$(RI)/MLGALML(RI)",
"TOTMKUS(RI)/BMUS10Y(RI)"),
datatype = "NAME",
startDate = as.Date("2022-04-27"),
endDate = as.Date("2022-04-27"),
frequency = "D")
})
expect_is(xtsData, "xts")
expect_equal(nrow(xtsData), 0)
expect_equal(ncol(xtsData), 2)
rm(mydsws, xtsData)
})
#######################################################################################
test_that("test of the instrument being an expression with economic data but call with wrong periodicity", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = "PCH#(USCONPRCF,12M)",
datatype = "",
startDate = as.Date("31/12/1960", "%d/%m/%Y"),
endDate = as.Date("31/12/2014", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################
test_that("test of three stock request", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("SAB", "RIO", "MKS"),
datatype = "P",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date("31/12/2014", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of multi stock timeseries request with an expression as the datatype", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("SAB", "RIO", "MKS"),
expression = "PCH#(XXXX,5D)",
startDate = as.Date("31/10/2015", "%d/%m/%Y"),
endDate = as.Date("15/11/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#############################################################
test_that("test of download worldscope data - this data is numeric", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("@AAPL"),
expression = "XXXX(WC01001A)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date('24/01/2012', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
myValues <- zoo::coredata(xtsData)
colnames(myValues) <- NULL
expect_equal(myValues[1:2,1], c(28237000, NA) )
rm(mydsws, xtsData)
})
#############################################################
test_that("test of lowercase RIC Codes", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("<WAFGn.DE>"),
expression = "XXXX",
startDate = as.Date("31/10/2016", "%d/%m/%Y"),
endDate = as.Date('24/11/2016', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
myValues <- zoo::coredata(xtsData)
colnames(myValues) <- NULL
expect_equal(myValues[1:2,1], c(32.770, 32.000) )
rm(mydsws, xtsData)
})
#############################################################
test_that("test of download worldscope data - this data is Dates", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("@AAPL"),
expression = "XXXX(WC05905A)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date('24/01/2012', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
myValues <- zoo::coredata(xtsData)
colnames(myValues) <- NULL
expect_is(myValues[1,1], "character")
expect_equal(myValues[1:2,1], c("2011-10-18", NA) ) # Date to be decoded
rm(mydsws, xtsData)
})
#############################################################
test_that("test of download worldscope data for multiple stocks", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("@AAPL", "MKS"),
expression = "XXXX(WC05905A)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date('24/01/2012', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#############################################################
test_that("test of Datastream expression eg 045E(XXXX)", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("@AAPL", "MKS"),
expression = "045E(XXXX)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date('24/01/2012', '%d/%m/%Y'),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
#############################################################
test_that("test of ISIN code and expression that was not being returned", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
mydsws$setLogging(3)
xtsData <- mydsws$timeSeriesRequest(instrument = c("JP3111200006","JP3802400006"),
expression = "(XXXX(SAL1FD12)/XXXX(SAL1TR12))-1.00",
startDate = as.Date("1996-01-01"),
endDate = as.Date("2016-01-20"),
frequency = "M")
expect_is(xtsData, "xts")
expect_equal(ncol(xtsData), 2L)
rm(mydsws, xtsData)
})
#############################################################
#
# test_that("test of selecting stocks via ISIN codes with missing (NA) codes and expressions", {
# if (is.null(options()$Datastream.Username)) {
# skip("Username not available")
# }
# skip_on_cran()
#
# mydsws <- dsws$new()
# xtsData <- mydsws$timeSeriesRequest(instrument = c("NO0010716582",NA,"SE0005999836",NA,"BMG454221059"),
# datatype = "P",
# startDate = as.Date("01/06/2015", "%d/%m/%Y"),
# endDate = as.Date("01/08/2015", "%d/%m/%Y"),
# frequency = "D")
#
# expect_is(xtsData, "xts")
# expect_equal(ncol(xts), 5L)
#
# rm(mydsws, xtsData)
#
# })
#############################################################
test_that("test of selecting stocks via ISIN codes with missing (NA) codes and expressions", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("NO0010716582",NA,"SE0005999836",NA,"BMG454221059"),
expression = "(XXXX(EPS1FD12)/XXXX(EPS1TR12))-1.00",
startDate = as.Date("01/06/2015", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
expect_equal(ncol(xtsData), 5L)
rm(mydsws, xtsData)
})
#############################################################
test_that("test of selecting stocks via ISIN codes with missing (NA) codes ", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
DSCodes <- c("JP3735400008", NA, "JP3305990008", "JP3117700009")
startDate <- as.Date("1994-12-02")
endDate <- as.Date("2018-01-23")
mydsws <- dsws$new()
xtsRepDates <- mydsws$timeSeriesRequest(instrument = DSCodes,
expression = "XXXX(WC05905A)",
startDate = startDate,
endDate = endDate,
frequency = "D",
format = "ByInstrument")
naRepDates <- xtsRepDates[ , 2]
expect_false(FALSE %in% is.na(naRepDates))
})
#############################################################
test_that("test of selecting stocks via ISIN codes with the first code missing and expressions", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c(NA,"NO0010716582","SE0005999836",NA,"BMG454221059"),
expression = "(XXXX(EPS1FD12)/XXXX(EPS1TR12))-1.00",
startDate = as.Date("01/06/2015", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
expect_equal(ncol(xtsData), 5L)
rm(mydsws, xtsData)
})
#############################################################
test_that("further test of missing stocks ", {
# In this test, nothing is returned from Datastream for the third stock. My thought is that
# the correct response should be an xts with a column per instrument
# and a single row (dated endDate) that has NA's in it.
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("CA91911K1021","US8552441094","VEV0019410A9",
"US5007541064","US4385161066"),
expression = "XXXX(BPS1TR12)/XXXX",
startDate = as.Date("2016-01-30"),
endDate = as.Date("2016-02-01"),
frequency = "D")
expect_is(xtsData, "xts")
expect_equal(ncol(xtsData), 5L)
expect_equal(nrow(xtsData), 2L)
expect_true(TRUE %in% is.na(xtsData[1,]))
rm(mydsws, xtsData)
})
#############################################################
test_that("test of Japanese ISIN with PE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("JP3677200002"),
expression = "XXXX(PE)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
test_that("test of ISIN returns Failure, status code 2, message $$\"ER\", 0904, NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("CA54042L1004"),
expression = "XXXX(PE)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
# This is a mixture of NO DATA AVAILABLE and valid data
#
test_that("test of ISIN returns mixture of NO DATA AVAILABLE and valid data", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
xtsData <- mydsws$timeSeriesRequest(instrument = c("CA54042L1004", "JP3677200002"),
expression = "XXXX(PE)",
startDate = as.Date("31/12/2011", "%d/%m/%Y"),
endDate = as.Date("01/08/2015", "%d/%m/%Y"),
frequency = "D")
expect_is(xtsData, "xts")
rm(mydsws, xtsData)
})
##############################################################################################
# This is a test of chunked requests - first make an unchunked one, and then a chunked one
#
test_that("test of chunked timeSeriesRequests with a datatype", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
symbolList <- mydsws$listRequest(instrument = "LFTSE100",
datatype = "MNEM",
requestDate = "0D")
# Get the unchunked data
xtsTestData <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
datatype = "PE",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsTestData, "xts")
# Get the same data with chunking
rm(mydsws)
mydsws <- dsws$new()
mydsws$chunkLimit <- 25L
xtsDataChunked <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
datatype = "PE",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsDataChunked, "xts")
expect_identical(xtsTestData, xtsDataChunked)
rm(mydsws, xtsTestData, xtsDataChunked, symbolList)
})
##############################################################################################
# This is a test of chunked requests - first make an unchunked one, and then a chunked one
#
test_that("test of chunked timeSeriesRequests with an expression", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
symbolList <- mydsws$listRequest(instrument = "LFTSE100",
datatype = "MNEM",
requestDate = "0D")
# Get the unchunked data
xtsTestData <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
expression = "XXXX(PE)",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsTestData, "xts")
# Get the same data with chunking
rm(mydsws)
mydsws <- dsws$new()
mydsws$chunkLimit <- 25L
xtsDataChunked <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
expression = "XXXX(PE)",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsDataChunked, "xts")
expect_identical(xtsTestData, xtsDataChunked)
rm(mydsws, xtsTestData, xtsDataChunked, symbolList)
})
##############################################################################################
# This is a test of setting chunkLimit via options()
#
test_that("test of setting chunkLimit via options()", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
myChunkLimit <- 123L
options(Datastream.ChunkLimit = myChunkLimit)
mydsws <- dsws$new()
expect_equal(mydsws$chunkLimit, myChunkLimit)
rm(mydsws, myChunkLimit)
options(Datastream.ChunkLimit = NULL)
})
##############################################################################################
# This is a test that if a chunk returns all NA it does not 'poison' the other chunks
#
test_that("test of single chunk returning NA", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
endDate = as.Date("2019-04-26")
expression = "HIDE#(XXXX(NERI0YR))"
frequency = "D"
startDate = as.Date("2019-04-26")
stocks <- readRDS(file.path(testDataFolder, "Europe600Codes.rds"))
mydsws <- dsws$new()
#mydsws$logging <- 60L
myDF <- mydsws$timeSeriesRequest(instrument = stocks,
expression = expression,
startDate = startDate,
endDate = endDate,
frequency = frequency)
expect_true(sum(!is.na(myDF)) > 0)
})
##############################################################################################
# This is a test of chunked requests - This is test that large requests strings are chunked correctly
#
test_that("test of chunking timeSeriesRequests due to request string length", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
symbolList <- mydsws$listRequest(instrument = "LFTSE100",
datatype = "MNEM",
requestDate = "0D")
# Get the unchunked data
xtsTestData <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
expression = "XXXX(PE)",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsTestData, "xts")
# Get the same data with chunking
rm(mydsws)
mydsws <- dsws$new()
mydsws$requestStringLimit <- 300L
xtsDataChunked <- mydsws$timeSeriesRequest(instrument = symbolList[,2],
expression = "XXXX(PE)",
startDate = as.Date("2011-08-31"),
endDate = as.Date("2011-11-30"),
frequency = "W")
expect_is(xtsDataChunked, "xts")
expect_identical(xtsTestData, xtsDataChunked)
rm(mydsws, xtsTestData, xtsDataChunked, symbolList)
})
##############################################################################################
# This is a test of named instruments requests
#
test_that("test of named instruments, datatypes and expressions", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
myIns <- c("@AAPL", "MKS")
names(myIns) <- c("a", "b")
myExp <- "XXXX(P)"
names(myExp) <- "c"
myDt <- "P"
names(myDt) <- "d"
# Expect
expect_silent(xtsTestData <- mydsws$timeSeriesRequest(instrument = myIns,
expression = myExp,
startDate = as.Date("2016-01-01"),
endDate = as.Date("2016-01-10"),
frequency = "D"))
expect_is(xtsTestData, "xts")
expect_true(nrow(xtsTestData) > 1)
expect_silent(xtsTestData <- mydsws$timeSeriesRequest(instrument = myIns,
datatype = myDt,
startDate = as.Date("2016-01-01"),
endDate = as.Date("2016-01-10"),
frequency = "D"))
expect_is(xtsTestData, "xts")
expect_true(nrow(xtsTestData) > 1)
rm(mydsws, myIns, myExp, myDt, xtsTestData)
})
##############################################################################################
# This is a test of chunked requests - This is test that large requests strings are chunked correctly
#
test_that("test of chunking timeSeriesRequests due to request string length", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
symbolList <- readRDS(file.path(testDataFolder, "G100DSCodes.rds"))
# Get the unchunked data
xtsTestData <- mydsws$timeSeriesRequest(instrument = symbolList,
expression = "XXXX(DWND)/XXXX(DWSE)*100.00",
startDate = as.Date("1996-01-01"),
endDate = as.Date("2016-01-10"),
frequency = "W")
expect_is(xtsTestData, "xts")
expect_true(ncol(xtsTestData) == 426)
expect_true(nrow(xtsTestData) == 1045)
rm(mydsws, xtsTestData, symbolList)
})
##############################################################################################
# This is a test of handling mainframe timeouts
#
test_that("test of handling mainframe timeouts", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
mydsws$jsonResponseLoadFile <- file.path(testDataFolder, "TimeoutResponseFull.json")
# Get the unchunked data
instCodes <- c("PCH#(US88033G4073(EPS1TR12),3Y)/100.000", "PCH#(US87612E1064(EPS1TR12),3Y)/100.000",
"PCH#(US87901J1051(EPS1TR12),3Y)/100.000", "PCH#(US8723751009(EPS1TR12),3Y)/100.000",
"PCH#(US8794338298(EPS1TR12),3Y)/100.000", "PCH#(US8718291078(EPS1TR12),3Y)/100.000",
"PCH#(US8636671013(EPS1TR12),3Y)/100.000", "PCH#(US8711301007(EPS1TR12),3Y)/100.000",
"PCH#(US8581222036(EPS1TR12),3Y)/100.000", "PCH#(US7865142084(EPS1TR12),3Y)/100.000",
"PCH#(US8545021011(EPS1TR12),3Y)/100.000", "PCH#(US8685361037(EPS1TR12),3Y)/100.000",
"PCH#(US8574771031(EPS1TR12),3Y)/100.000", "PCH#(US7908491035(EPS1TR12),3Y)/100.000",
"PCH#(US8679141031(EPS1TR12),3Y)/100.000", "PCH#(US8110544025(EPS1TR12),3Y)/100.000",
"PCH#(US8550301027(EPS1TR12),3Y)/100.000", "PCH#(US8354951027(EPS1TR12),3Y)/100.000",
"PCH#(US8425871071(EPS1TR12),3Y)/100.000", "PCH#(US87161C5013(EPS1TR12),3Y)/100.000",
"PCH#(US78442P1066(EPS1TR12),3Y)/100.000", "PCH#(AN8068571086(EPS1TR12),3Y)/100.000",
"PCH#(US8265521018(EPS1TR12),3Y)/100.000", "PCH#(US8202861022(EPS1TR12),3Y)/100.000",
"PCH#(US8243481061(EPS1TR12),3Y)/100.000", "PCH#(US8066051017(EPS1TR12),3Y)/100.000",
"PCH#(US8270561025(EPS1TR12),3Y)/100.000", "PCH#(US8175651046(EPS1TR12),3Y)/100.000",
"PCH#(US8085131055(EPS1TR12),3Y)/100.000", "PCH#(US80589M1027(EPS1TR12),3Y)/100.000",
"PCH#(US7864291007(EPS1TR12),3Y)/100.000", "PCH#(US7551115071(EPS1TR12),3Y)/100.000",
"PCH#(US7504381036(EPS1TR12),3Y)/100.000", "PCH#(US2578671016(EPS1TR12),3Y)/100.000",
"PCH#(US7753711073(EPS1TR12),3Y)/100.000", "PCH#(US7617631012(EPS1TR12),3Y)/100.000",
"PCH#(US7591EP1005(EPS1TR12),3Y)/100.000", "PCH#(US7616951056(EPS1TR12),3Y)/100.000",
"PCH#(US0019201070(EPS1TR12),3Y)/100.000", "PCH#(US7581101000(EPS1TR12),3Y)/100.000",
"PCH#(US7512773026(EPS1TR12),3Y)/100.000", "PCH#(US7677541044(EPS1TR12),3Y)/100.000",
"PCH#(US7835491082(EPS1TR12),3Y)/100.000", "PCH#(US7475251036(EPS1TR12),3Y)/100.000",
"PCH#(US74005P1049(EPS1TR12),3Y)/100.000", "PCH#(US7310951055(EPS1TR12),3Y)/100.000",
"PCH#(US6951141083(EPS1TR12),3Y)/100.000", "PCH#(US69351T1060(EPS1TR12),3Y)/100.000",
"PCH#(US6935061076(EPS1TR12),3Y)/100.000")
xtsTestData <- mydsws$timeSeriesRequest(instrument = instCodes,
expression = "",
startDate = as.Date("2017-02-01"),
endDate = as.Date("2017-03-03"),
frequency = "D")
expect_is(xtsTestData, "xts")
expect_true(ncol(xtsTestData) == 49)
expect_true(nrow(xtsTestData) == 23)
rm(mydsws, xtsTestData, instCodes)
})
##############################################################################################
# This is a test of that if a single timeseries returns $$ER: 0904,NO DATA AVAILABLE and no dates
# the dsws returns a zero row xts.
# Issue # 4
# json response of server stored in testData/test-dsws-timeSeriesRequest-test04.json
#
test_that(" test of that if a single timeseries returns $$ER: 0904,NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
# Get the unchunked data
xtsActData <- mydsws$timeSeriesRequest(instrument = "KO:SGL",
datatype = "AX",
startDate = "2018-05-07",
endDate = "2018-05-09",
frequency = "D")
expect_is(xtsActData, "xts")
expect_true(ncol(xtsActData) == 1)
expect_true(nrow(xtsActData) == 0)
rm(mydsws, xtsActData)
})
##############################################################################################
# This is a test of that if a we request two timeseries and the first returns $$ER: 0904,NO DATA AVAILABLE
# we get then dsws returns an xts with rows.
# Issue # 4
#
test_that("equest two timeseries and the first returns $$ER: 0904,NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
# Get the unchunked data
xtsActData <- mydsws$timeSeriesRequest(instrument = c("III", "KO:SGL"),
datatype = "AX",
startDate = "2018-05-03",
endDate = "2018-05-07",
frequency = "D")
expect_is(xtsActData, "xts")
expect_true(ncol(xtsActData) == 2)
expect_true(nrow(xtsActData) == 3)
rm(mydsws, xtsActData)
})
##############################################################################################
# This is a test of that if a we request two timeseries and the second returns $$ER: 0904,NO DATA AVAILABLE
# we get then dsws returns an xts with rows.
# Issue # 4
#
test_that("test of that if a we request two timeseries and the second returns $$ER: 0904,NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
# Get the unchunked data
xtsActData <- mydsws$timeSeriesRequest(instrument = c("KO:SGL", "III"),
datatype = "AX",
startDate = "2018-05-03",
endDate = "2018-05-07",
frequency = "D")
expect_is(xtsActData, "xts")
expect_true(ncol(xtsActData) == 2)
expect_true(nrow(xtsActData) == 3)
rm(mydsws, xtsActData)
})
##############################################################################################
# This is a test of that if a we request two timeseries and both return $$ER: 0904,NO DATA AVAILABLE
# we get then dsws returns an xts with zero rows.
# Issue # 4
#
test_that(" test of that if a single timeseries returns $$ER: 0904,NO DATA AVAILABLE", {
if (Sys.getenv("DatastreamUsername") == "") {
skip("Username not available")
}
skip_on_cran()
mydsws <- dsws$new()
# Get the unchunked data
xtsActData <- mydsws$timeSeriesRequest(instrument = c("III", "KO:SGL"),
datatype = "AX",
startDate = "2018-05-07",
endDate = "2018-05-09",
frequency = "D")
expect_is(xtsActData, "xts")
expect_true(ncol(xtsActData) == 2)
expect_true(nrow(xtsActData) == 0)
rm(mydsws, xtsActData)
})
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
Embedding an R snippet on your website
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.