def test_updating_module_attributes(self):
dashboard = DashboardFactory(title='test dashboard')
module = ModuleFactory(dashboard=dashboard,
title='module-title',
data_set=DataSetFactory())
new_data_set = DataSetFactory(data_group__name='new-group-title',
data_type__name='new-type-title')
dashboard_data = dashboard.serialize()
dashboard_data['modules'][0]['title'] = 'new module title'
dashboard_data['modules'][0]['data_group'] = 'new-group-title'
dashboard_data['modules'][0]['data_type'] = 'new-type-title'
dashboard_data['modules'][0]['order'] = 1
dashboard_data['modules'][0]['type_id'] = module.type_id
dashboard_data['modules'][0]['query_parameters'] = {
'sort_by': 'thing:desc',
}
dashboard_data['modules'][0]['modules'] = []
resp = self.client.put('/dashboard/{}'.format(dashboard.id),
json.dumps(dashboard_data, cls=JsonEncoder),
content_type="application/json",
HTTP_AUTHORIZATION='Bearer correct-token')
module_from_db = Module.objects.get(id=module.id)
assert_that(resp.status_code, equal_to(200))
assert_that(module_from_db.title, equal_to('new module title'))
assert_that(module_from_db.data_set_id, equal_to(new_data_set.id))
def test_put_404_when_user_not_in_data_set_ownership_array(self):
collector = CollectorFactory()
collector_user, _ = User.objects.get_or_create(
email='*****@*****.**')
collector.owners.add(collector_user)
data_set = DataSetFactory()
data_set_user, _ = User.objects.get_or_create(
email='*****@*****.**')
data_set.owners.add(data_set_user)
collector_update = {
"slug": collector.slug,
"type_id": collector.type.id,
"data_source_id": collector.data_source.id,
"data_set": {
"data_type": data_set.data_type.name,
"data_group": data_set.data_group.name
}
}
response = self.client.put('/collector/{}'.format(collector.slug),
data=to_json(collector_update),
HTTP_AUTHORIZATION='Bearer correct-token',
content_type='application/json')
assert_that(response.status_code, equal_to(404))
def setUpClass(cls):
cls.data_group = DataGroupFactory(name='group')
cls.data_type = DataTypeFactory(name='type')
cls.data_set = DataSetFactory(
data_group=cls.data_group,
data_type=cls.data_type,
)
cls.module_type = ModuleTypeFactory(
name='a-type',
schema={
'type': 'object',
'properties': {
'thing': {
'type': 'string',
'required': True
}
},
'$schema': "http://json-schema.org/draft-03/schema#"
}
)
cls.dashboard = DashboardFactory(
published=True,
title='A service',
slug='some-slug',
)
def test_list_transforms_for_dataset_and_type_with_no_group(self):
data_set = DataSetFactory()
set_transform = TransformFactory(
input_group=data_set.data_group,
input_type=data_set.data_type,
)
type_transform = TransformFactory(
input_type=data_set.data_type,
)
resp = self.client.get(
'/data-sets/{}/transform'.format(data_set.name),
HTTP_AUTHORIZATION='Bearer development-oauth-access-token')
assert_that(resp.status_code, is_(200))
resp_json = json.loads(resp.content)
assert_that(len(resp_json), is_(2))
assert_that(
resp_json,
has_item(has_entry('id', str(set_transform.id))))
assert_that(
resp_json,
has_item(has_entry('id', str(type_transform.id))))
def setUpClass(cls):
cls.data_group = DataGroupFactory(name='group')
cls.data_type = DataTypeFactory(name='type')
cls.data_set = DataSetFactory(
data_group=cls.data_group,
data_type=cls.data_type,
)
cls.module_type = ModuleTypeFactory(name='graph', schema={})
cls.dashboard_a = DashboardFactory(slug='a-dashboard', published=False)
cls.dashboard_b = DashboardFactory(slug='b-dashboard', published=False)
def setUpClass(cls):
cls.data_group = DataGroupFactory(
name='transactional-services',
)
cls.data_type = DataTypeFactory(
name='summaries',
)
cls.data_set = DataSetFactory(
data_group=cls.data_group,
data_type=cls.data_type,
)
def test_create_produces_a_name(self):
data_type = DataTypeFactory(name="a_type")
data_group = DataGroupFactory(name="a_group")
data_set = DataSetFactory(data_type=data_type, data_group=data_group)
collector_type = CollectorTypeFactory(name="a_collector_type")
collector = CollectorFactory(type=collector_type, data_set=data_set)
assert_that(collector.name, contains_string("a_type"))
assert_that(collector.name, contains_string("a_group"))
assert_that(collector.name, contains_string("a_collector_type"))
def test_get_404_when_user_not_in_data_set_ownership_array(self):
data_set = DataSetFactory()
data_set_user, _ = User.objects.get_or_create(
email='*****@*****.**')
data_set.owners.add(data_set_user)
collector = CollectorFactory(data_set=data_set)
collector_user, _ = User.objects.get_or_create(
email='*****@*****.**')
collector.owners.add(collector_user)
resp = self.client.get('/collector/{}'.format(collector.slug),
HTTP_AUTHORIZATION='Bearer correct-token')
assert_that(resp.status_code, equal_to(404))
def test_empty_dataset_no_confirmed(self):
dataset = DataSetFactory()
dataset_admin = DataSetAdmin(dataset, None)
request = RequestFactory()
request.method = 'POST'
request.POST = {
'_empty_dataset': '',
}
calls = []
with HTTMock(empty_dataset_response(calls)):
response = dataset_admin.response_change(request, dataset)
assert_that(len(calls), is_(0))
assert_that(response, instance_of(HttpResponseRedirect))
assert_that(str(response.url), contains_string(str(dataset.pk)))
def test_empty_dataset(self):
dataset = DataSetFactory()
dataset_admin = DataSetAdmin(dataset, None)
request = HttpRequest()
request.method = 'POST'
request.POST = {
'_empty_dataset': '',
}
calls = []
with HTTMock(empty_dataset_response(calls)):
response = dataset_admin.response_change(request, dataset)
assert_that(len(calls), is_(1))
assert_that(
calls[0][0],
is_('/data/{}/{}'.format(dataset.data_group.name,
dataset.data_type.name)))
assert_that(response, instance_of(HttpResponseRedirect))
assert_that(str(response.url), contains_string(str(dataset.pk)))
def setUpClass(cls):
cls.data_group = DataGroupFactory(name='group')
cls.data_type = DataTypeFactory(name='type')
cls.data_set = DataSetFactory(
data_group=cls.data_group,
data_type=cls.data_type,
)
cls.module_type = ModuleTypeFactory(
name='a-type',
schema={
'type': 'object',
'properties': {
'thing': {
'type': 'string',
'required': True
}
},
'$schema': "http://json-schema.org/draft-03/schema#"
})
cls.dashboard = DashboardFactory(
published=True,
title='A service',
slug='some-slug',
)
cls.dashboard_without_owner = DashboardFactory(
published=True,
title='Another service',
slug='some-other-slug',
)
cls.user, _ = User.objects.get_or_create(
email='*****@*****.**')
cls.dashboard.owners.add(cls.user)
def setUpClass(cls):
cls.provider = ProviderFactory()
cls.data_source = DataSourceFactory(provider=cls.provider)
cls.collector_type = CollectorTypeFactory(provider=cls.provider)
cls.data_set = DataSetFactory()
def test_truncated_slug_is_replaced_in_modules():
DataSetFactory(data_group__name='transactional-services',
data_type__name='summaries')
ModuleTypeFactory(name='kpi')
ModuleTypeFactory(name='bar_chart_with_number')
munger = SpreadsheetMunger({
'names_transaction_name': 11,
'names_transaction_slug': 12,
'names_service_name': 9,
'names_service_slug': 10,
'names_tx_id': 19,
'names_other_notes': 17,
'names_description': 8,
})
mock_account = Mock()
mock_account.open_by_key() \
.worksheet().get_all_values.return_value = tx_worksheet
tx = munger.load_tx_worksheet(mock_account)
mock_account = Mock()
mock_account.open_by_key() \
.worksheet().get_all_values.return_value = names_worksheet
names = munger.load_names_worksheet(mock_account)
record = munger.merge(tx, names)[0]
truncated_slug = 'truncated-{}'.format(random.randrange(1e7))
full_tx_id = record['tx_id']
record['tx_id'] = truncated_slug
DashboardFactory(slug=truncated_slug)
summaries = [{
'service_id': record['tx_id'],
'type': 'quarterly',
'cost_per_transaction': 0,
'digital_takeup': 0
}, {
'service_id': record['tx_id'],
'type': 'seasonally-adjusted',
'total_cost': 0
}, {
'service_id': full_tx_id,
'type': 'quarterly',
'cost_per_transaction': 0,
'digital_takeup': 0
}, {
'service_id': full_tx_id,
'type': 'seasonally-adjusted',
'total_cost': 0
}]
import_dashboard(record, summaries, dry_run=False)
initial_modules = Module.objects.all()
service_id_filters = set([
module.query_parameters['filter_by'][0] for module in initial_modules
])
assert_that(len(service_id_filters), equal_to(1))
assert_that(service_id_filters.pop(),
equal_to('service_id:{}'.format(truncated_slug)))
record['tx_id'] = full_tx_id
record['tx_truncated'] = truncated_slug
import_dashboard(record, summaries, dry_run=False)
new_modules = Module.objects.all()
assert_that(len(new_modules), equal_to(len(initial_modules)))
service_id_filters = set(
[module.query_parameters['filter_by'][0] for module in new_modules])
assert_that(len(service_id_filters), equal_to(1))
assert_that(service_id_filters.pop(),
equal_to('service_id:{}'.format(full_tx_id)))
