def test_delete_dataverse(self):
connection = Connection(TEST_HOST, self.token)
alias = str(uuid.uuid1()) # must be unique
dataverse = connection.create_dataverse(
alias,
'Test Name',
'*****@*****.**',
)
connection.delete_dataverse(dataverse)
dataverse = connection.get_dataverse(alias)
assert dataverse is None
def test_get_dataverse(self):
connection = Connection(TEST_HOST, self.token)
alias = str(uuid.uuid1()) # must be unique
assert connection.get_dataverse(alias) is None
dataverse = connection.create_dataverse(
alias,
'Test Name',
'*****@*****.**',
)
try:
assert dataverse is not None
assert dataverse.alias == alias
finally:
connection.delete_dataverse(dataverse)
def test_connect_unknown_failure(self):
httpretty.register_uri(
httpretty.GET,
'https://{host}/dvn/api/data-deposit/v1.1/swordv2/service-document'
.format(host=TEST_HOST),
status=400,
)
with pytest.raises(exceptions.ConnectionError):
Connection(TEST_HOST, self.token)
def setUpClass(self):
print "Connecting to DVN."
self.dvc = Connection(
username=DEFAULT_USERNAME,
password=DEFAULT_PASSWORD,
host=DEFAULT_HOST,
disable_ssl=True
)
print "Getting Dataverse"
self.dv = self.dvc.get_dataverses()[0]
self.dv.is_released
print "Removing any existing studies."
studies = self.dv.get_studies()
for study in studies :
if study.get_state() != 'DEACCESSIONED':
self.dv.delete_study(study)
print 'Dataverse emptied.'
def setup_class(cls):
print 'Connecting to Dataverse host at {0}'.format(TEST_HOST)
cls.connection = Connection(TEST_HOST, TEST_TOKEN)
print 'Creating test Dataverse'
cls.alias = str(uuid.uuid1())
cls.connection.create_dataverse(
cls.alias,
'Test Dataverse',
'*****@*****.**',
)
cls.dataverse = cls.connection.get_dataverse(cls.alias, True)
assert cls.dataverse
def setup_class(cls):
super(TestDatasetOperations, cls).setup_class()
print('Connecting to Dataverse host at {0}'.format(TEST_HOST))
cls.connection = Connection(TEST_HOST, cls.token)
print('Creating test Dataverse')
cls.alias = str(uuid.uuid1())
cls.connection.create_dataverse(
cls.alias,
'Test Dataverse',
'*****@*****.**',
)
cls.dataverse = cls.connection.get_dataverse(cls.alias, True)
assert cls.dataverse
def test_create_dataverse(self):
connection = Connection(TEST_HOST, self.token)
alias = str(uuid.uuid1()) # must be unique
connection.create_dataverse(
alias,
'Test Name',
'*****@*****.**',
)
dataverse = connection.get_dataverse(alias, True)
try:
assert dataverse.alias == alias
assert dataverse.title == 'Test Name'
finally:
connection.delete_dataverse(dataverse)
def test_delete_dataverse(self):
connection = Connection(TEST_HOST, self.token)
alias = str(uuid.uuid1()) # must be unique
dataverse = connection.create_dataverse(
alias,
'Test Name',
'*****@*****.**',
)
connection.delete_dataverse(dataverse)
dataverse = connection.get_dataverse(alias)
assert dataverse is None
def setUpClass(self):
print "Connecting to DVN."
self.dvc = Connection(TEST_HOST, TEST_TOKEN)
print "Getting Dataverse"
dataverses = self.dvc.get_dataverses()
if not dataverses:
raise DataverseError(
'You must have a Dataverse to run these tests.'
)
self.dv = dataverses[0]
print "Removing any existing datasets."
datasets = self.dv.get_datasets()
for dataset in datasets:
if dataset.get_state() != 'DEACCESSIONED':
self.dv.delete_dataset(dataset)
print 'Dataverse emptied.'
def test_create_dataverse(self):
connection = Connection(TEST_HOST, self.token)
alias = str(uuid.uuid1()) # must be unique
connection.create_dataverse(
alias,
'Test Name',
'*****@*****.**',
)
dataverse = connection.get_dataverse(alias, True)
try:
assert dataverse.alias == alias
assert dataverse.title == 'Test Name'
finally:
connection.delete_dataverse(dataverse)
def test_get_dataverse(self):
connection = Connection(TEST_HOST, self.token)
alias = str(uuid.uuid1()) # must be unique
assert connection.get_dataverse(alias) is None
dataverse = connection.create_dataverse(
alias,
'Test Name',
'*****@*****.**',
)
try:
assert dataverse is not None
assert dataverse.alias == alias
finally:
connection.delete_dataverse(dataverse)
def test_get_dataverses(self):
connection = Connection(TEST_HOST, self.token)
original_dataverses = connection.get_dataverses()
assert isinstance(original_dataverses, list)
alias = str(uuid.uuid1()) # must be unique
dataverse = connection.create_dataverse(
alias,
'Test Name',
'*****@*****.**',
)
current_dataverses = connection.get_dataverses()
try:
assert len(current_dataverses) == len(original_dataverses) + 1
assert alias in [dv.alias for dv in current_dataverses]
finally:
connection.delete_dataverse(dataverse)
current_dataverses = connection.get_dataverses()
assert [dv.alias for dv in current_dataverses
] == [dv.alias for dv in original_dataverses]
def test_get_dataverses(self):
connection = Connection(TEST_HOST, self.token)
original_dataverses = connection.get_dataverses()
assert isinstance(original_dataverses, list)
alias = str(uuid.uuid1()) # must be unique
dataverse = connection.create_dataverse(
alias,
'Test Name',
'*****@*****.**',
)
current_dataverses = connection.get_dataverses()
try:
assert len(current_dataverses) == len(original_dataverses) + 1
assert alias in [dv.alias for dv in current_dataverses]
finally:
connection.delete_dataverse(dataverse)
current_dataverses = connection.get_dataverses()
assert [dv.alias for dv in current_dataverses] == [dv.alias for dv in original_dataverses]
def test_connect(self):
connection = Connection(TEST_HOST, TEST_TOKEN)
assert connection.host == TEST_HOST
assert connection.token == TEST_TOKEN
assert connection._service_document
def main():
dv = None # declare outside so except clause has access
try:
dvc = Connection(
username=DEFAULT_USERNAME,
password=DEFAULT_PASSWORD,
host=DEFAULT_HOST,
disable_ssl=True,
)
dvs = dvc.get_dataverses()
for dv in dvs:
print dv
dv = dvs[0]
# clean up the test dataverse
# for study in dv.get_studies():
# dv.delete_study(study)
# print "RELEASED:", dv.is_released()
s = dv.get_studies()[0]
# s = Study(EXAMPLE_DICT)
# s = Study(EXAMPLE_FILE)
# print s
print s.doi
# s.delete_all_files()
# s.add_file("dataverseclient/resources/test/one.txt")
# s.delete_file(s.get_file("one.txt"))
# s.add_file("dataverseclient/resources/test")
s.get_statement()
print s.get_entry()
# s.add_files([INGEST_FILES])
# print s.get_citation()
# print s.get_state()
# sleep(3) #wait for ingest`
# fs = s.get_files()
# print "FILES: ", len(fs)
# s.delete_file(fs[-1])
# fs = s.get_files()
# print "FILES: ", len(fs)
# s.delete_all_files()
# fs = s.get_files()
# print "FILES: ", len(fs)
# s.release()
# s.hostDataverse.delete_study(s)
print "\n\nclient succeeded"
except Exception as e:
sleep(1)
traceback.print_exc()
sleep(1)
if dv:
try:
dv.swordConnection.history = json.dumps(
dv.connection.swordConnection.history, indent=True)
except:
pass
class TestStudyOperations(unittest.TestCase):
@classmethod
def setUpClass(self):
print "Connecting to DVN."
self.dvc = Connection(
username=DEFAULT_USERNAME,
password=DEFAULT_PASSWORD,
host=DEFAULT_HOST,
disable_ssl=True
)
print "Getting Dataverse"
self.dv = self.dvc.get_dataverses()[0]
self.dv.is_released
print "Removing any existing studies."
studies = self.dv.get_studies()
for study in studies :
if study.get_state() != 'DEACCESSIONED':
self.dv.delete_study(study)
print 'Dataverse emptied.'
def setUp(self):
#runs before each test method
#create a study for each test
s = Study(**PICS_OF_CATS_STUDY)
self.dv.add_study(s)
doi = s.doi
self.s = self.dv.get_study_by_doi(doi)
self.assertEqual(doi, self.s.doi)
return
def tearDown(self):
try:
self.dv.delete_study(self.s)
finally:
return
def test_create_study_from_xml(self):
new_study = Study.from_xml_file(ATOM_STUDY)
self.dv.add_study(new_study)
retrieved_study = self.dv.get_study_by_title("Roasting at Home")
self.assertTrue(retrieved_study)
self.dv.delete_study(retrieved_study)
def test_add_files(self):
self.s.add_files(['test_dvn.py', 'config.py'])
sleep(3) #wait for ingest
actual_files = [f.name for f in self.s.get_files()]
self.assertIn('test_dvn.py', actual_files)
self.assertIn('config.py', actual_files)
def test_upload_file(self):
self.s.upload_file('file.txt', 'This is a simple text file!')
self.s.upload_file('file2.txt', 'This is the second simple text file!')
sleep(3) #wait for ingest
actual_files = [f.name for f in self.s.get_files()]
self.assertIn('file.txt', actual_files)
self.assertIn('file2.txt', actual_files)
def test_display_atom_entry(self):
# this just tests we can get an entry back, but does
# not do anything with that xml yet. however, we do use get_entry
# in other methods so this test case is probably covered
self.assertTrue(self.s.get_entry())
def test_display_study_statement(self):
# this just tests we can get an entry back, but does
# not do anything with that xml yet. however, we do use get_statement
# in other methods so this test case is probably covered
self.assertTrue(self.s.get_statement())
def test_delete_a_file(self):
self.s.upload_file('cat.jpg', b'Whatever a cat looks like goes here.')
#add file and confirm
files = self.s.get_files()
cat_file = [f for f in files if f.name == 'cat.jpg']
self.assertTrue(len(cat_file) == 1)
#delete file and confirm
self.s.delete_file(cat_file[0])
files = self.s.get_files()
cat_file = [f for f in files if f.name == "cat.jpg"]
self.assertTrue(len(cat_file) == 0)
def test_delete_a_study(self):
xmlStudy = Study.from_xml_file(ATOM_STUDY)
self.dv.add_study(xmlStudy)
atomStudy = self.dv.get_study_by_title("Roasting at Home")
self.assertTrue(atomStudy)
startingNumberOfStudies = len(self.dv.get_studies())
self.assertTrue(startingNumberOfStudies > 0)
self.dv.delete_study(atomStudy)
self.assertEqual(atomStudy.get_state(refresh=True), 'DEACCESSIONED')
self.assertEqual(len(self.dv.get_studies()), startingNumberOfStudies - 1)
def test_release_study(self):
self.assertTrue(self.s.get_state() == "DRAFT")
self.s.release()
self.assertTrue(self.s.get_state() == "RELEASED")
self.dv.delete_study(self.s)
self.assertTrue(self.s.get_state(refresh=True) == "DEACCESSIONED")
def test_dataverse_released(self):
self.assertTrue(self.dv.is_released)
def test_connect_unauthorized(self):
with pytest.raises(exceptions.UnauthorizedError):
Connection(TEST_HOST, 'wrong-token')
def test_connect(self):
connection = Connection(TEST_HOST, self.token)
assert connection.host == TEST_HOST
assert connection.token == self.token
assert connection._service_document
def main():
dv = None # declare outside so except clause has access
try:
dvc = Connection(
username=DEFAULT_USERNAME,
password=DEFAULT_PASSWORD,
host=DEFAULT_HOST,
disable_ssl=True,
)
dvs = dvc.get_dataverses()
for dv in dvs:
print dv
dv = dvs[0]
# clean up the test dataverse
# for study in dv.get_studies():
# dv.delete_study(study)
# print "RELEASED:", dv.is_released()
s = dv.get_studies()[0]
# s = Study(EXAMPLE_DICT)
# s = Study(EXAMPLE_FILE)
# print s
print s.doi
# s.delete_all_files()
# s.add_file("dataverseclient/resources/test/one.txt")
# s.delete_file(s.get_file("one.txt"))
# s.add_file("dataverseclient/resources/test")
s.get_statement()
print s.get_entry()
# s.add_files([INGEST_FILES])
# print s.get_citation()
# print s.get_state()
# sleep(3) #wait for ingest`
# fs = s.get_files()
# print "FILES: ", len(fs)
# s.delete_file(fs[-1])
# fs = s.get_files()
# print "FILES: ", len(fs)
# s.delete_all_files()
# fs = s.get_files()
# print "FILES: ", len(fs)
# s.release()
# s.hostDataverse.delete_study(s)
print "\n\nclient succeeded"
except Exception as e:
sleep(1)
traceback.print_exc()
sleep(1)
if dv:
try:
dv.swordConnection.history = json.dumps(dv.connection.swordConnection.history, indent=True)
except:
pass
class TestDatasetOperations(unittest.TestCase):
@classmethod
def setUpClass(self):
print "Connecting to DVN."
self.dvc = Connection(TEST_HOST, TEST_TOKEN)
print "Getting Dataverse"
dataverses = self.dvc.get_dataverses()
if not dataverses:
raise DataverseError(
'You must have a Dataverse to run these tests.'
)
self.dv = dataverses[0]
print "Removing any existing datasets."
datasets = self.dv.get_datasets()
for dataset in datasets:
if dataset.get_state() != 'DEACCESSIONED':
self.dv.delete_dataset(dataset)
print 'Dataverse emptied.'
def setUp(self):
# runs before each test method
# create a dataset for each test
s = Dataset(**PICS_OF_CATS_DATASET)
self.dv.add_dataset(s)
doi = s.doi
self.s = self.dv.get_dataset_by_doi(doi)
self.assertEqual(doi, self.s.doi)
return
def tearDown(self):
try:
self.dv.delete_dataset(self.s)
finally:
return
def test_create_dataset_from_xml(self):
new_dataset = Dataset.from_xml_file(ATOM_DATASET)
self.dv.add_dataset(new_dataset)
retrieved_dataset = self.dv.get_dataset_by_title("Roasting at Home")
self.assertTrue(retrieved_dataset)
self.dv.delete_dataset(retrieved_dataset)
def test_add_files(self):
self.s.add_files(['test_dataverse.py', 'config.py'])
actual_files = [f.name for f in self.s.get_files()]
self.assertIn('test_dataverse.py', actual_files)
self.assertIn('config.py', actual_files)
def test_upload_file(self):
self.s.upload_file('file.txt', 'This is a simple text file!')
self.s.upload_file('file2.txt', 'This is the second simple text file!')
actual_files = [f.name for f in self.s.get_files()]
self.assertIn('file.txt', actual_files)
self.assertIn('file2.txt', actual_files)
def test_display_atom_entry(self):
# this just tests we can get an entry back, but does
# not do anything with that xml yet. however, we do use get_entry
# in other methods so this test case is probably covered
self.assertTrue(self.s.get_entry())
def test_display_dataset_statement(self):
# this just tests we can get an entry back, but does
# not do anything with that xml yet. however, we do use get_statement
# in other methods so this test case is probably covered
self.assertTrue(self.s.get_statement())
def test_delete_a_file(self):
self.s.upload_file('cat.jpg', b'Whatever a cat looks like goes here.')
#add file and confirm
files = self.s.get_files()
cat_file = [f for f in files if f.name == 'cat.jpg']
self.assertTrue(len(cat_file) == 1)
#delete file and confirm
self.s.delete_file(cat_file[0])
files = self.s.get_files()
cat_file = [f for f in files if f.name == "cat.jpg"]
self.assertTrue(len(cat_file) == 0)
def test_delete_a_dataset(self):
xmlDataset = Dataset.from_xml_file(ATOM_DATASET)
self.dv.add_dataset(xmlDataset)
atomDataset = self.dv.get_dataset_by_title("Roasting at Home")
self.assertTrue(atomDataset)
num_datasets = len(self.dv.get_datasets())
self.assertTrue(num_datasets > 0)
self.dv.delete_dataset(atomDataset)
self.assertEqual(atomDataset.get_state(refresh=True), 'DEACCESSIONED')
self.assertEqual(len(self.dv.get_datasets()), num_datasets - 1)
@unittest.skip('Published datasets can no longer be deaccessioned via API')
def test_publish_dataset(self):
self.assertTrue(self.s.get_state() == "DRAFT")
self.s.publish()
self.assertTrue(self.s.get_state() == "PUBLISHED")
self.dv.delete_dataset(self.s)
self.assertTrue(self.s.get_state(refresh=True) == "DEACCESSIONED")
