def test_doesnt_leave_leftovers(self):
container = ConfigurationContainer(
{"a": 1, "b": "test", "e": 3}, configuration_schema
)
new_config = container.to_dict(mask_secrets=True)
new_config.pop("e")
container.update(new_config)
self.assertEqual(container["a"], 1)
self.assertEqual("test", container["b"])
self.assertNotIn("e", container)
def test_connection_bad_test(self):
self.factory.create_data_source(
name="test1",
type="sqlite",
options=ConfigurationContainer({"dbpath": __file__}),
)
runner = CliRunner()
result = runner.invoke(manager, ["ds", "test", "test1"])
self.assertTrue(result.exception)
self.assertEqual(result.exit_code, 1)
self.assertIn("Failure", result.output)
def test_connection_test(self):
self.factory.create_data_source(
name="test1",
type="sqlite",
options=ConfigurationContainer({"dbpath": "/tmp/test.db"}),
)
runner = CliRunner()
result = runner.invoke(manager, ["ds", "test", "test1"])
self.assertFalse(result.exception)
self.assertEqual(result.exit_code, 0)
self.assertIn("Success", result.output)
def test_list(self):
self.factory.create_data_source(name='test1',
type='pg',
options=ConfigurationContainer({
"host":
"example.com",
"dbname":
"testdb1"
}))
self.factory.create_data_source(name='test2',
type='sqlite',
options=ConfigurationContainer(
{"dbpath": "/tmp/test.db"}))
self.factory.create_data_source(name='Atest',
type='sqlite',
options=ConfigurationContainer(
{"dbpath": "/tmp/test.db"}))
runner = CliRunner()
result = runner.invoke(manager, ['ds', 'list'])
self.assertFalse(result.exception)
self.assertEqual(result.exit_code, 0)
expected_output = """
Id: 3
Name: Atest
Type: sqlite
Options: {"dbpath": "/tmp/test.db"}
--------------------
Id: 1
Name: test1
Type: pg
Options: {"dbname": "testdb1", "host": "example.com"}
--------------------
Id: 2
Name: test2
Type: sqlite
Options: {"dbpath": "/tmp/test.db"}
"""
self.assertMultiLineEqual(result.output,
textwrap.dedent(expected_output).lstrip())
def test_bad_type_edit(self):
self.factory.create_data_source(
name="test1",
type="sqlite",
options=ConfigurationContainer({"dbpath": "/tmp/test.db"}),
)
runner = CliRunner()
result = runner.invoke(manager, ["ds", "edit", "test", "--type", "wrong"])
self.assertTrue(result.exception)
self.assertEqual(result.exit_code, 1)
self.assertIn("not supported", result.output)
ds = DataSource.query.first()
self.assertEqual(ds.type, "sqlite")
def post(self):
req = request.get_json(True)
required_fields = ('options', 'name', 'type')
for f in required_fields:
if f not in req:
abort(400)
schema = get_configuration_schema_for_query_runner_type(req['type'])
if schema is None:
abort(400)
config = ConfigurationContainer(filter_none(req['options']), schema)
# from IPython import embed
# embed()
if not config.is_valid():
abort(400)
try:
datasource = models.DataSource.create_with_group(
org=self.current_org,
name=req['name'],
type=req['type'],
options=config)
models.db.session.commit()
# Refresh the stored schemas when a new data source is added to the list
refresh_schemas.apply_async(queue=settings.SCHEMAS_REFRESH_QUEUE)
except IntegrityError as e:
if req['name'] in e.message:
abort(400,
message="Data source with the name {} already exists.".
format(req['name']))
abort(400)
self.record_event({
'action': 'create',
'object_id': datasource.id,
'object_type': 'datasource'
})
return datasource.to_dict(all=True)
def post(self):
req = request.get_json(True)
require_fields(req, ('options', 'name', 'type'))
schema = get_configuration_schema_for_destination_type(req['type'])
if schema is None:
abort(400)
config = ConfigurationContainer(req['options'], schema)
if not config.is_valid():
abort(400)
destination = models.NotificationDestination(org=self.current_org,
name=req['name'],
type=req['type'],
options=config,
user=self.current_user)
models.db.session.add(destination)
models.db.session.commit()
return destination.to_dict(all=True)
def post(self):
req = request.get_json(True)
required_fields = ('options', 'name', 'type')
for f in required_fields:
if f not in req:
abort(400)
schema = get_configuration_schema_for_type(req['type'])
if schema is None:
abort(400)
config = ConfigurationContainer(req['options'], schema)
if not config.is_valid():
abort(400)
datasource = models.DataSource.create_with_group(org=self.current_org,
name=req['name'],
type=req['type'],
options=config)
return datasource.to_dict(all=True)
def post(self):
req = request.get_json(True)
require_fields(req, ('options', 'name', 'type'))
schema = get_configuration_schema_for_query_runner_type(req['type'])
if schema is None:
abort(400)
config = ConfigurationContainer(filter_none(req['options']), schema)
# from IPython import embed
# embed()
if not config.is_valid():
abort(400)
try:
datasource = models.DataSource.create_with_group(
org=self.current_org,
name=req['name'],
type=req['type'],
folder_id=req['folder_id'],
options=config)
models.db.session.commit()
except IntegrityError as e:
if req['name'] in e.message:
abort(400,
message="Data source with the name {} already exists.".
format(req['name']))
abort(400)
self.record_event({
'action': 'create',
'object_id': datasource.id,
'object_type': 'datasource'
})
return datasource.to_dict(all=True)
def setUp(self):
self.config = {'a': 1, 'b': 'test'}
self.container = ConfigurationContainer(self.config,
configuration_schema)
def test_works_for_schema_without_secret(self):
secretless = configuration_schema.copy()
secretless.pop("secret")
container = ConfigurationContainer({"a": 1, "b": "test", "e": 3}, secretless)
container.update({"a": 2})
self.assertEqual(container["a"], 2)
def setUp(self):
self.config = {"a": 1, "b": "test"}
self.container = ConfigurationContainer(self.config, configuration_schema)
def test_works_for_schema_without_secret(self):
secretless = configuration_schema.copy()
secretless.pop('secret')
container = ConfigurationContainer({'a': 1, 'b': 'test', 'e': 3}, secretless)
container.update({'a': 2})
self.assertEqual(container['a'], 2)
