Permalink
Browse files

Update unit tests to reduce network requests to D1

  • Loading branch information...
gothub committed Jun 20, 2018
1 parent 09fa393 commit 8585f2bb86ead10ca661934cd508b833409adee8
@@ -1,6 +1,7 @@
# Reduce redundant calls to the same service - this only needs to be made
# once per test
cnProd <- CNode()
cnStaging2 <- CNode("STAGING2")
d1cKNB <- D1Client("PROD", "urn:node:KNB")
mnKNB <- d1cKNB@mn
d1cProd <- D1Client("PROD")
@@ -5,20 +5,16 @@ test_that("dataone library loads", {
test_that("CNode constructors", {
library(dataone)
# If not specified, "PROD" environment is used.
#cn <- CNode()
expect_match(cnProd@endpoint, "https://cn.dataone.org/cn")
#cn <- CNode("PROD")
expect_match(cnProd@endpoint, "https://cn.dataone.org/cn")
# Skip unstable test environments.
skip_on_cran()
cn <- CNode("STAGING2")
expect_match(cn@endpoint, "https://cn-stage-2.test.dataone.org/cn")
expect_match(cnStaging2@endpoint, "https://cn-stage-2.test.dataone.org/cn")
#cn <- CNode("DEV")
#expect_match(cn@endpoint, "https://cn-dev.test.dataone.org/cn")
})
test_that("CNode listNodes()", {
library(dataone)
#cn <- CNode("PROD")
nodelist <- listNodes(cnProd)
expect_that(length(nodelist) > 0, is_true())
expect_match(class(nodelist[[1]]), "Node")
@@ -34,7 +30,6 @@ test_that("CNode listNodes()", {
test_that("CNode getObject()", {
library(dataone)
library(XML)
#cn <- CNode("PROD")
pid <- "aceasdata.3.2"
obj <- getObject(cnProd, pid)
if(is.null(obj) || class(obj) != "raw") {
@@ -51,15 +46,13 @@ test_that("CNode getObject()", {

test_that("CNode getSystemMetadata()", {
library(dataone)
#cn <- CNode("PROD")
pid <- "aceasdata.3.2"
sysmeta <- getSystemMetadata(cnProd, pid)
expect_match(sysmeta@identifier, pid)
})

test_that("CNode describeObject()", {
library(dataone)
#cn <- CNode("PROD")
pid <- "aceasdata.3.2"
res <- dataone::describeObject(cnProd, pid)
expect_is(res, "list")
@@ -69,7 +62,6 @@ test_that("CNode describeObject()", {
test_that("CNode getMNode()", {
library(dataone)
skip_on_cran()
#cn <- CNode("PROD")
nodelist <- listNodes(cnProd)
nodeid <- nodelist[[length(nodelist)]]@identifier
newnode <- getMNode(cnProd, nodeid)
@@ -84,7 +76,6 @@ test_that("CNode getMNode()", {

test_that("CNode resolve()",{
library(dataone)
#cn <- CNode("PROD")
id <- "0d7d8e0e-93f5-40ab-9916-501d7cf93e15"
res <- resolve(cnProd,id)
expect_match(res$id, id)
@@ -96,27 +87,26 @@ test_that("CNode reserveIdentifier(), hasReservation() works",{
skip_on_cran()
library(dataone)
library(uuid)
cn <- CNode("STAGING2")

# For hasReservation(), we have to use the same subject that is in the authorization token or X.509 certificate.
# Until the dataone package can decrypt auth tokens, we have to manually provide same subject
# used by reserveIdentifier.
am <- AuthenticationManager()
# Suppress openssl, cert missing warnings
suppressMessages(authValid <- dataone:::isAuthValid(am, cn))
suppressMessages(authValid <- dataone:::isAuthValid(am, cnStaging2))
# First check if authentication is available and if not, skip this test
if (authValid) {
# TODO: remove this check when Mac OS X can be used with certificates
if(dataone:::getAuthMethod(am, cn) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
if(dataone:::getAuthMethod(am, cnStaging2) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
# Set 'subject' to authentication subject, if available, so this userId can check a reservation that it made
subject <- dataone:::getAuthSubject(am, cn)
subject <- dataone:::getAuthSubject(am, cnStaging2)
myId <- sprintf("urn:uuid:%s", UUIDgenerate())
# researveIdentifier will create the reservation using only the client subject from
# the current authentication method - either auth token or certificate.
newId <- reserveIdentifier(cn, myId)
newId <- reserveIdentifier(cnStaging2, myId)
expect_match(myId, newId)
# Have to specify the subject for hasReservation
hasRes <- hasReservation(cn, newId, subject=subject)
hasRes <- hasReservation(cnProd, newId, subject=subject)
expect_true(hasRes, info=sprintf("Didn't find reserved identifier %s", myId))
} else {
skip("This test requires valid authentication.")
@@ -18,8 +18,7 @@ test_that("D1Client constructors", {
# Skip the remainder of the tests because these test environments are
# often down due to upgrades, reconfiguring, testing new features.
skip_on_cran()
cn <- CNode("STAGING2")
cli <- new("D1Client", cn=cn, mn=getMNode(cn, "urn:node:mnTestKNB"))
cli <- new("D1Client", cn=cnStaging2, mn=getMNode(cnStaging2, "urn:node:mnTestKNB"))
expect_false(is.null(cli))
expect_match(class(cli), "D1Client")
expect_match(cli@cn@baseURL, "https://cn.stage-2.test.dataone.org/cn")
@@ -5,22 +5,21 @@ test_that("dataone library loads", {

test_that("CNode ping", {
library(dataone)
cn <- CNode("PROD")
alive <- ping(cn)
# 'cnProd' is defined in 'helper-base.R' for all tests
alive <- ping(cnProd)
expect_true(alive)
})

test_that("CNode object index query works with query list param", {
library(dataone)
# Test query of CN object index using query string
queryParams <- "q=id:doi*&rows=2&wt=xml"
cn <- CNode("PROD")
am <- AuthenticationManager()
suppressMessages(authValid <- dataone:::isAuthValid(am, cn))
suppressMessages(authValid <- dataone:::isAuthValid(am, cnProd))
if (authValid) {
if(getAuthMethod(am, cn) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
if(getAuthMethod(am, cnProd) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
}
result <- query(cn, queryParams, as="list")
result <- query(cnProd, queryParams, as="list")
#resultList <- parseSolrResult(result)
expect_true(length(result) == 2)
expect_match(result[[2]]$id, "doi:")
@@ -30,7 +29,7 @@ test_that("CNode object index query works with query list param", {

# Test query of CN object index using query list
queryParamList <- list(q="id:doi*", rows="5", fq="(abstract:chlorophyll AND dateUploaded:[2000-01-01T00:00:00Z TO NOW])", fl="title,id,abstract,size,dateUploaded,attributeName", wt="xml")
result <- query(cn, queryParamList, as="list")
result <- query(cnProd, queryParamList, as="list")
expect_true(length(result) > 0)
expect_match(result[[1]]$id, "doi:")
size <- result[[1]]$size
@@ -41,42 +40,41 @@ test_that("CNode object index query works with query list param", {
# Test a query that contains embedded quotes
queryParamList <- list(q="(attribute:lake) and (attribute:\"Percent Nitrogen\")", rows="10",
fl="title,id,abstract,size,dateUploaded,attributeName", wt="xml")
result <- query(cn, queryParamList, as="data.frame")
result <- query(cnProd, queryParamList, as="data.frame")
expect_true(class(result) == "data.frame")
expect_true(nrow(result) > 0)

# Test if query can handle solr syntax error
queryParamList <- list(q="(attribute:lake) and attribute:\"Percent Nitrogen\")", rows="10",
fl="title,id,abstract,size,dateUploaded,attributeName", wt="xml")
result <- query(cn, queryParamList, as="data.frame")
result <- query(cnProd, queryParamList, as="data.frame")
expect_true(is.null(result))

# Test if query can handle solr syntax error (mispelled field name "attr")
queryParamList <- list(q="(attribute:lake) and attr:\"Percent Nitrogen\")", rows="10",
fl="title,id,abstract,size,dateUploaded,attributeName", wt="xml")
result <- query(cn, queryParamList, as="data.frame")
result <- query(cnProd, queryParamList, as="data.frame")
expect_true(is.null(result))
})

test_that("Object listing works for CNode, MNode", {
library(dataone)

# Note: this test assumes that there are at least 5 EML 2.1.0 documents in DataONE
cn <- CNode("PROD")
fromDate <- "2001-01-01T01:01:01.000+00:00"
toDate <- "2015-12-31T01:01:01.000+00:00"
formatId <- "eml://ecoinformatics.org/eml-2.1.0"
start <- 0
count <- 5
objects <- listObjects(cn, fromDate=fromDate, toDate=toDate, formatId=formatId, start=start, count=count)
objects <- listObjects(cnProd, fromDate=fromDate, toDate=toDate, formatId=formatId, start=start, count=count)
# The XML parser used in listObjects creates one more element than returned elements, used to hold attributes?
expect_equal(length(objects) - 1, count)
for (i in 1:(length(objects)-1) ) {
expect_match(objects[i]$objectInfo$formatId, formatId)
}
# Note: this test assumes that there are at least 5 EML 2.1.0 documents in KNB
mn <- getMNode(cn, "urn:node:KNB")
objects <- listObjects(cn, fromDate=fromDate, toDate=toDate, formatId=formatId, start=start, count=count)
#mn <- getMNode(cnProd, "urn:node:KNB")
objects <- listObjects(cnProd, fromDate=fromDate, toDate=toDate, formatId=formatId, start=start, count=count)
# The XML parser used in listObjects creates one more element than returned elements, used to hold attributes?
expect_equal(length(objects) - 1, count)
for (i in 1:(length(objects)-1) ) {
@@ -86,33 +84,31 @@ test_that("Object listing works for CNode, MNode", {
# Test invalid input
fromDate <- "20-01-01T01:01:01.000+00:00" # Invalid year
toDate <- "2015-12-31T01:01:01.000+00:00" # valid
err <- try(objects <- listObjects(cn, fromDate=fromDate, toDate=toDate, formatId=formatId, start=start, count=count), silent=TRUE)
err <- try(objects <- listObjects(cnProd, fromDate=fromDate, toDate=toDate, formatId=formatId, start=start, count=count), silent=TRUE)
expect_match(class(err), ("try-error"))

fromDate <- "2013-01-01T01:01:01.000+00:00" # valid
toDate <- "01/01/15" # Invalid - not ISO 8601
try(objects <- listObjects(cn, fromDate=fromDate, toDate=toDate, formatId=formatId, start=start, count=count), silent=TRUE)
try(objects <- listObjects(cnProd, fromDate=fromDate, toDate=toDate, formatId=formatId, start=start, count=count), silent=TRUE)
expect_match(class(err), ("try-error"))

})

test_that("listQueryEngines, getQueryEngineDescription works for CNode, MNode", {
library(dataone)

#cn <- CNode("STAGING2")
# Get list of query engines for a CN, and get description for each engine
cn <- CNode("PROD")
engines <- listQueryEngines(cn)
engines <- listQueryEngines(cnProd)
expect_gt(length(engines), 0)
for (i in 1:length(engines)) {
engineDesc <- getQueryEngineDescription(cn, engines[[i]])
engineDesc <- getQueryEngineDescription(cnProd, engines[[i]])
expect_gt(length(engineDesc), 0)
expect_match(engineDesc$name, engines[[i]])
expect_true(class(engineDesc$queryFields) == "data.frame")
}

# Get list of query engines for an MN, and get description for each engine
mn <- getMNode(cn, "urn:node:KNB")
mn <- getMNode(cnProd, "urn:node:KNB")
engines <- listQueryEngines(mn)
expect_gt(length(engines), 0)
for (i in 1:length(engines)) {
@@ -127,16 +123,15 @@ test_that("listQueryEngines, getQueryEngineDescription works for CNode, MNode",
test_that("CNode object index query works with query string param", {
library(dataone)

cn <- CNode("PROD")
am <- AuthenticationManager()
suppressMessages(authValid <- dataone:::isAuthValid(am, cn))
suppressMessages(authValid <- dataone:::isAuthValid(am, cnProd))
if (authValid) {
if(getAuthMethod(am, cn) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
if(getAuthMethod(am, cnProd) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
}
# This test assumes that there are at least two pids on KNB that are DOIs (i.e. begin with "doi:")
# This test requests two results and checks that 2 results are returned.
queryParams <- "q=id:doi*&rows=2&wt=xml"
result <- query(cn, queryParams, as="list")
result <- query(cnProd, queryParams, as="list")
expect_true(length(result) == 2)
expect_match(result[[2]]$id, "doi:")
size <- result[[1]]$size
@@ -147,14 +142,14 @@ test_that("MNode object index query works", {
library(dataone)
queryParams <- "q=id:doi*&rows=2&wt=xml"
#queryParams <- 'q=attribute:"net primary production" AND (abstract:"above ground" OR title:"above ground")'
mn_uri <- "https://knb.ecoinformatics.org/knb/d1/mn/v2"
mn <- MNode(mn_uri)
#mn_uri <- "https://knb.ecoinformatics.org/knb/d1/mn/v2"
#mn <- MNode(mn_uri)
am <- AuthenticationManager()
suppressMessages(authValid <- dataone:::isAuthValid(am, mn))
suppressMessages(authValid <- dataone:::isAuthValid(am, mnKNB))
if (authValid) {
if(getAuthMethod(am, mn) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
if(getAuthMethod(am, mnKNB) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
}
result <- query(mn, queryParams, as="list")
result <- query(mnKNB, queryParams, as="list")
expect_true(length(result) > 0)
pid <- result[[1]]$id
expect_is(pid, "character")
@@ -171,11 +166,11 @@ test_that("MNode object index query works", {
}

# Request that an XML object is returned
result <- query(mn, queryParams, as="xml", parse=TRUE)
result <- query(mnKNB, queryParams, as="xml", parse=TRUE)
expect_is(result, "XMLInternalDocument")

# Request that a character object is returned
result <- query(mn, queryParams, as="xml", parse=FALSE)
result <- query(mnKNB, queryParams, as="xml", parse=FALSE)
expect_is(result, "character")
expect_match(result, "<?xml")
})
@@ -189,7 +184,6 @@ test_that("D1Node archive() works",{
write.csv(testdf, csvfile, row.names=FALSE)
#mnId <- "urn:node:mnStageUCSB2"
#d1c <- new("D1Client", env="STAGING", mNodeid=mnId)
d1cTest
am <- AuthenticationManager()
suppressMessages(authValid <- dataone:::isAuthValid(am, d1cTest@mn))
if (authValid) {
@@ -223,28 +217,27 @@ test_that("D1Node archive() works",{
test_that("D1Node isAuthorized() works",{
skip_on_cran()
library(dataone)
cn <- CNode("PROD")
am <- AuthenticationManager()
suppressMessages(authValid <- dataone:::isAuthValid(am, cn))
suppressMessages(authValid <- dataone:::isAuthValid(am, cnProd))
# Don't use a cert on Mac OS X
if (authValid) {
if(getAuthMethod(am, cn) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
if(getAuthMethod(am, cnProd) == "cert" && grepl("apple-darwin", sessionInfo()$platform)) skip("Skip authentication w/cert on Mac OS X")
}
# Send an authorization check to the D1 production CN.
canRead <- isAuthorized(cn, "doi:10.6073/pasta/7fcb8fea57843fae65f63094472f502d", "read")
canRead <- isAuthorized(cnProd, "doi:10.6073/pasta/7fcb8fea57843fae65f63094472f502d", "read")
expect_true(canRead)
canWrite <- isAuthorized(cn, "doi:10.6073/pasta/7fcb8fea57843fae65f63094472f502d", "write")
canWrite <- isAuthorized(cnProd, "doi:10.6073/pasta/7fcb8fea57843fae65f63094472f502d", "write")
expect_false(canWrite)
canChange <- isAuthorized(cn, "doi:10.6073/pasta/7fcb8fea57843fae65f63094472f502d", "changePermission")
canChange <- isAuthorized(cnProd, "doi:10.6073/pasta/7fcb8fea57843fae65f63094472f502d", "changePermission")
expect_false(canChange)

# Now send a check to a member node.
mn <- getMNode(cn, "urn:node:KNB")
canRead <- isAuthorized(mn, "doi:10.6085/AA/pisco_recruitment.149.1", "read")
#mn <- getMNode(cnProd, "urn:node:KNB")
canRead <- isAuthorized(mnKNB, "doi:10.6085/AA/pisco_recruitment.149.1", "read")
expect_true(canRead)
canWrite <- isAuthorized(mn, "doi:10.6085/AA/pisco_recruitment.149.1", "write")
canWrite <- isAuthorized(mnKNB, "doi:10.6085/AA/pisco_recruitment.149.1", "write")
expect_false(canWrite)
canChange <- isAuthorized(mn, "doi:10.6085/AA/pisco_recruitment.149.1", "changePermission")
canChange <- isAuthorized(mnKNB, "doi:10.6085/AA/pisco_recruitment.149.1", "changePermission")
expect_false(canChange)
})

Oops, something went wrong.

0 comments on commit 8585f2b

Please sign in to comment.