class TestDelete(unittest.TestCase):
def setUp(self):
self.connection = Connection(username, password)
delete_projects_by_name(self.connection, test_project_name)
self.project = Project(self.connection).create(test_project_name, gd_token)
def tearDown(self):
self.project.delete()
def test_column_maql_delete(self):
dataset = Department(self.project)
dataset.create()
expected_maql_delete_department_row = "DELETE FROM {attr.department.department}"\
+ " WHERE {label.department.city} IN (\"Boston\", \"NYC\");"
self.assertEquals(
expected_maql_delete_department_row,
dataset.get_maql_delete(where_clause="{label.department.city} IN (\"Boston\", \"NYC\")")
)
expected_maql_delete_department_row_with_ids = "DELETE FROM {attr.department.department}"\
+ " WHERE {label.department.department} IN (\"d1\", \"d2\");"
self.assertEquals(
expected_maql_delete_department_row_with_ids,
dataset.get_maql_delete(where_values=["d1", "d2"])
)
self.assertEquals(
expected_maql_delete_department_row_with_ids,
dataset.get_maql_delete(column=dataset.department, where_values=["d1", "d2"])
)
expected_maql_delete_city_row = "DELETE FROM {attr.department.city}"\
+ " WHERE {label.department.city} IN (\"Boston\", \"NYC\");"
self.assertEquals(
expected_maql_delete_city_row,
dataset.get_maql_delete(
column=dataset.city,
where_clause="{label.department.city} IN (\"Boston\", \"NYC\")"
)
)
self.assertEquals(
expected_maql_delete_city_row,
dataset.get_maql_delete(
column=dataset.city,
where_values=["Boston", "NYC"]
)
)
self.assertRaises(RowDeletionError, dataset.get_maql_delete)
expected_maql_delete_row_with_id = "DELETE FROM {attr.department.city}"\
+ " WHERE {label.department.city} IN (119, 120);"
self.assertEquals(
expected_maql_delete_row_with_id,
dataset.get_maql_delete(
column=dataset.city,
where_values=[119, 120]
)
)
def test_create_and_delete_project(self):
project = Project(self.connection).create(TEST_PROJECT_NAME)
self.assert_(project is not None)
self.assert_(project.id is not None)
project.delete()
self.assertRaises(ProjectNotOpenedError, project.delete)
self.assertRaises(ProjectNotFoundError, project.load,
name=TEST_PROJECT_NAME)
def test_create_and_delete_project(self):
project = Project(self.connection).create(TEST_PROJECT_NAME)
self.assert_(project is not None)
self.assert_(project.id is not None)
project.delete()
self.assertRaises(ProjectNotOpenedError, project.delete)
self.assertRaises(ProjectNotFoundError,
project.load,
name=TEST_PROJECT_NAME)
def test_create_and_delete_project(self):
project = Project(self.connection).create(test_project_name, gd_token)
self.assert_(project is not None)
self.assert_(project.id is not None)
project.delete()
self.assertRaises(ProjectNotOpenedError, project.delete)
self.assertRaises(ProjectNotFoundError, project.load,
name=test_project_name)
def test_create_structure(self):
project = Project(self.connection).create(TEST_PROJECT_NAME)
self.assertRaises(MaqlExecutionFailed, project.execute_maql, 'CREATE DATASET {dat')
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(project)
self.assertRaises(DataSetNotFoundError, dataset.get_metadata,
name=dataset.schema_name)
dataset.create()
self.assert_(dataset.get_metadata(name=dataset.schema_name))
project.delete()
def test_create_structure(self):
project = Project(self.connection).create(TEST_PROJECT_NAME)
self.assertRaises(MaqlExecutionFailed, project.execute_maql,
'CREATE DATASET {dat')
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(project)
self.assertRaises(DataSetNotFoundError,
dataset.get_metadata,
name=dataset.schema_name)
dataset.create()
self.assert_(dataset.get_metadata(name=dataset.schema_name))
project.delete()
class TestDataset(unittest.TestCase):
def setUp(self):
self.connection = Connection(username, password, debug=0)
#drop all the test projects:
delete_projects_by_name(self.connection, TEST_PROJECT_NAME)
self.project = Project(self.connection).create(TEST_PROJECT_NAME)
def tearDown(self):
self.project.delete()
def test_create_date_dimension(self):
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(self.project)
date_dimension = dataset.get_date_dimension()
if date_dimension:
DateDimension(self.project).create(name=date_dimension.schemaReference,
include_time=date_dimension.datetime)
# TODO: verify the creation
def test_upload_dataset(self):
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(self.project)
dataset.upload()
dataset_metadata = dataset.get_metadata(name=dataset.schema_name)
self.assert_(dataset_metadata['dataUploads'])
self.assertEquals('OK', dataset_metadata['lastUpload']['dataUploadShort']['status'])
dataset.upload()
# TODO: check different data for the upload
def test_date_maql(self):
date_dimension = DateDimension(self.project)
self.assertEquals('INCLUDE TEMPLATE "URN:GOODDATA:DATE"', date_dimension.get_maql())
self.assertEquals('INCLUDE TEMPLATE "URN:GOODDATA:DATE" MODIFY (IDENTIFIER "test", TITLE "Test");\n\n',
date_dimension.get_maql('Test'))
self.assertEquals(examples.forex.date_dimension_maql, date_dimension.get_maql('Forex', include_time=True))
self.assertEquals(examples.forex.date_dimension_maql.replace('forex', 'xerof').replace('Forex', 'Xerof'),
date_dimension.get_maql('Xerof', include_time=True))
def test_sli_manifest(self):
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(Project(None))
sli_manifest = dataset.get_sli_manifest()
self.assertEqual(example.sli_manifest, sli_manifest)
class TestDataset(unittest.TestCase):
def setUp(self):
self.connection = Connection(username, password)
delete_projects_by_name(self.connection, test_project_name)
self.project = Project(self.connection).create(test_project_name, gd_token)
def tearDown(self):
self.project.delete()
def test_create_dataset(self):
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(self.project)
dataset.create()
dataset.get_metadata(dataset.schema_name)
def test_upload_dataset(self):
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(self.project)
dataset.upload()
dataset_metadata = dataset.get_metadata(name=dataset.schema_name)
self.assertTrue(dataset_metadata['dataUploads'])
self.assertEquals('OK', dataset_metadata['lastUpload']['dataUploadShort']['status'])
def test_date_dimension(self):
date_dimension = DateDimension(self.project)
self.assertEquals('INCLUDE TEMPLATE "URN:GOODDATA:DATE"', date_dimension.get_maql())
self.assertEquals('INCLUDE TEMPLATE "URN:GOODDATA:DATE" MODIFY (IDENTIFIER "test", TITLE "Test");\n\n',
date_dimension.get_maql('Test'))
self.assertEquals(examples.forex.date_dimension_maql, date_dimension.get_maql('Forex', include_time=True))
self.assertEquals(examples.forex.date_dimension_maql.replace('forex', 'xerof').replace('Forex', 'Xerof'),
date_dimension.get_maql('Xerof', include_time=True))
def test_sli_manifest(self):
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(self.project)
sli_manifest = dataset.get_sli_manifest()
self.assertIsInstance(sli_manifest, dict)
self.assertEquals('INCREMENTAL', sli_manifest['dataSetSLIManifest']['parts'][0]['mode'])
sli_manifest = dataset.get_sli_manifest(full_upload=True)
self.assertEquals('FULL', sli_manifest['dataSetSLIManifest']['parts'][0]['mode'])
def test_dates_sli_manifest(self):
_datetime = Date(title='Created at', schemaReference='created_at', datetime=True)
_datetime.set_name_and_schema('_name', '_schema')
self.assertEquals(
'yyyy-MM-dd HH:mm:SS',
_datetime.get_sli_manifest_part(full_upload=False)[0]['constraints']['date']
)
_date = Date(title='Created at', schemaReference='created_at', datetime=False)
_date.set_name_and_schema('_name', '_schema')
self.assertEquals(
'yyyy-MM-dd',
_date.get_sli_manifest_part(full_upload=False)[0]['constraints']['date']
)
def test_no_upload(self):
'''
test that no connection to GD API is made.
Uses a mock connection that will raise an error if put is called
'''
csv_file = os.path.join(os.path.abspath('./'), 'tmp.csv')
def mock_put(uri, data, headers):
raise Exception('GD API should not be called')
self.project.connection.webdav.put = mock_put
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(self.project)
dataset.upload(
no_upload=True, keep_csv=True,
csv_file=csv_file
)
os.remove(csv_file)
def test_exceptions(self):
class DummyDataset(Dataset):
pass
dataset = DummyDataset(self.project)
self.assertRaises(DataSetNotFoundError, dataset.get_metadata, 'dummy_dataset')
self.assertRaises(NotImplementedError, dataset.data)
def test_upload_dataset_with_csv(self):
department, Department = examples.examples[0]
self.dataset = Department(self.project)
self.dataset.create()
csv_input_path = 'tests/examples/department_data.csv'
self.dataset.upload(csv_input_path=csv_input_path)
dataset_metadata = self.dataset.get_metadata(name=self.dataset.schema_name)
self.assertTrue(dataset_metadata['dataUploads'])
self.assertEquals('OK', dataset_metadata['lastUpload']['dataUploadShort']['status'])
def test_validate_maql(self):
project = Project(self.connection).create(test_project_name, gd_token)
self.assertRaises(MaqlValidationFailed, project.execute_maql, 'CREATE DATASET {dat')
self.assertRaises(AttributeError, project.execute_maql, '')
project.delete()
class TestState(unittest.TestCase):
def setUp(self):
self.connection = Connection(username, password)
delete_projects_by_name(self.connection, test_project_name)
self.project = Project(self.connection).create(test_project_name, gd_token)
def tearDown(self):
self.project.delete()
def test_has_properties(self):
department = examples.examples[0][1](self.project)
department.create()
worker = examples.examples[1][1](self.project)
worker.create()
salary = examples.examples[2][1](self.project)
salary.create()
# attributes
self.assertTrue(department.has_attribute('department'))
self.assertTrue(department.has_attribute('city'))
self.assertFalse(department.has_attribute('town'))
# facts
self.assertTrue(salary.has_fact('payment'))
self.assertFalse(worker.has_fact('name'))
self.assertFalse(worker.has_fact('age'))
# labels
self.assertTrue(department.has_label('name'))
self.assertFalse(department.has_label('city'))
self.assertFalse(department.has_label('building'))
# references
self.assertTrue(worker.has_reference('department'))
self.assertFalse(worker.has_reference('jungle'))
self.assertTrue(salary.has_reference('worker'))
# dates
self.assertTrue(salary.has_date('payday'))
self.assertFalse(salary.has_date('expires_at'))
self.assertFalse(department.has_date('birthday'))
def test_remote_columns(self):
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(self.project)
dataset.create()
for (example, ExampleDataset) in examples.examples:
dataset = ExampleDataset(self.project)
columns = dataset.get_remote_columns()
self.assertListEqual(sorted(columns), sorted(dict(dataset._columns).keys()))
for col_name, col in columns.iteritems():
dataset_col = getattr(dataset, col_name)
self.assertIs(type(col), type(dataset_col))
# references have no title on the API...
if not isinstance(col, Reference):
self.assertEqual(col.title, dataset_col.title)
self.assertEqual(col.dataType, dataset_col.dataType)
self.assertEqual(col.reference, dataset_col.reference)
self.assertEqual(col.schemaReference, dataset_col.schemaReference)
self.assertEqual(col.datetime, dataset_col.datetime)
def test_remote_diff(self):
Department = examples.examples[0][1]
Department(self.project).create()
Worker = examples.examples[1][1]
Worker(self.project).create()
Salary = examples.examples[2][1]
Salary(self.project).create()
old_city = Department.city
old_name = Department.name
Department.name = HyperLink(title='Name', reference='department', folder='Department', dataType='VARCHAR(128)')
Department.city = None
Department.town = Attribute(title='Town', folder='Department', dataType='VARCHAR(20)')
remote_diff = Department(self.project).get_remote_diff()
self.assertIn('town', remote_diff['added'])
self.assertIn('name', remote_diff['altered'])
self.assertIn('city', remote_diff['deleted'])
self.assertEqual(remote_diff['added']['town'], Department.town)
self.assertEqual(remote_diff['altered']['name']['new'], Department.name)
self.assertEqual(remote_diff['altered']['name']['old'], old_name)
self.assertEqual(remote_diff['deleted']['city'], old_city)
old_dpt = Worker.department
Worker.department = None
remote_diff = Worker(self.project).get_remote_diff()
self.assertIn('department', remote_diff['deleted'])
self.assertFalse(remote_diff['added'])
self.assertFalse(remote_diff['altered'])
self.assertEqual(remote_diff['deleted']['department'], old_dpt)
Salary.payment = Fact(title='Payment', folder='Salary', dataType='BIGINT')
remote_diff = Salary(self.project).get_remote_diff()
self.assertIn('payment', remote_diff['altered'])
self.assertFalse(remote_diff['added'])
self.assertFalse(remote_diff['deleted'])
def test_remote_diff_factsof(self):
class Snapshot(Dataset):
wrong_snapshot_id = Attribute(title='snapshot_id', dataType='VARCHAR(20)')
Snapshot(self.project).create()
remote_diff = Snapshot(self.project).get_remote_diff()
self.assertTrue('factsof' not in remote_diff['deleted'])
Snapshot.real_snapshot_id = ConnectionPoint(title='snapshot_id')
remote_diff = Snapshot(self.project).get_remote_diff()
self.assertTrue('factsof' in remote_diff['deleted'])
