def setUp(self):
# Override some behaviours that are difficult to mock.
self.original_update_questionnaire_store = QuestionnaireManager.update_questionnaire_store
QuestionnaireManager.update_questionnaire_store = MagicMock(return_value=None)
# Class under test.
self.questionnaire_manager = QuestionnaireManager(MagicMock(), MagicMock())
# Mock answer store.
answer_store = MagicMock()
answer_store.filter = MagicMock(return_value=[])
self.answer_store = answer_store
# Mock question.
self.question = MagicMock()
# Mock answers.
answers = []
for i in range(3):
answers.append(mock_answer('answer', i, self.question))
self.answers = answers
self.questionnaire_manager.block_state = MagicMock()
self.questionnaire_manager.block_state.get_answers = MagicMock(return_value=self.answers)
def test_rss_creation(self, data, refresh, resp, created, expected_request, side_effect=None):
# Include data to mock
self.request.raw_post_data = json.dumps(data)
# Mock ExpenditureManager
self.views.ExpenditureManager = MagicMock()
# Mock ModelManager
self.views.ModelManager = MagicMock()
# Create a mock method to manage the token refresh
# if needed
if refresh:
exp_mock = ExpenditureMock()
self.views.ExpenditureManager = exp_mock.ExpenditureManager
# Create social auth mocks
social_mock = MagicMock()
filter_mock = MagicMock()
object_mock = MagicMock()
object_mock.extra_data = {
'access_token': 'accesstoken',
'refresh_token': 'refreshtoken'
}
filter_mock.return_value = [object_mock]
social_mock.filter = filter_mock
self.request.user.social_auth = social_mock
# Create the corresponding side effect if needed
if side_effect:
side_effect(self)
# Call the view
collection = self.views.RSSCollection(permitted_methods=('GET', 'POST'))
response = collection.create(self.request)
# Check response
val = json.loads(response.content)
self.assertEquals(response.status_code, resp[0])
self.assertEquals(val['message'], resp[1])
self.assertEquals(val['result'], resp[2])
# Check the result depending if the model should
# have been created
if created:
# Check rss call
model_info = None
if 'models' in data:
model_info = data['models']
revenue_model = self._generate_models(model_info)
self.views.RSS.objects.create.assert_called_with(name=data['name'], host=data['host'], expenditure_limits=expected_request, revenue_models=revenue_model)
self.assertEquals(self.rss_object.access_token, self.user.userprofile.access_token)
else:
self.views.RSS.objects.delete.assert_called_once()
def test_filter_queryset_by_permissions_exception(self):
queryset = MagicMock()
user = MagicMock()
divider = MagicMock()
user.is_authenticated = MagicMock(return_value=True)
user.is_superuser = False
user.is_admin = False
user.is_staff = False
queryset.filter().distinct = MagicMock(side_effect=Exception)
filter_queryset_by_permissions(queryset=queryset,
user=user,
divider=divider)
def test_apply_filter_function(self):
queryset = MagicMock()
queryset.filter = MagicMock(return_value='queryset_filtered')
timestamp_start = 123456789
queryset, timestamp_end = apply_filter_since(queryset, timestamp_start)
self.assertEqual(queryset, 'queryset_filtered')
self.assertIn(
int(timestamp_end),
[
int(pendulum.instance(timezone.now()).timestamp()),
int(pendulum.instance(timezone.now()).timestamp()) - 1,
],
)
def test_get_next_answer_instance_one_more_than_previous_answers(self):
# Given
qm = self.questionnaire_manager
answer_store = MagicMock()
answer_schema = MagicMock()
answers = [{'answer_instance': '5'}]
answer_store.filter = MagicMock(return_value=answers)
# When
next_id = qm._get_next_answer_instance(answer_store, answer_schema) # pylint: disable=protected-access
# Then
self.assertEqual(next_id, 6)
def test_get_logged_in_char(self):
"""Tests if the get_logged_in_char behaves as expected.
The test asserts if the returned value of the function is the return value
of the mocked out database query. Also asserts if the query was called with
the right parameters.
"""
character = MagicMock()
character.filter = MagicMock()
character.filter.return_value = 'test'
test = get_logged_in_char(character)
character.filter.assert_called_with(is_logged=True)
self.assertEqual(test, 'test')
def test_GIVEN_no_model_runs_WHEN_get_model_list_THEN_empty_list_returned(self):
mock_query_result = MagicMock()
mock_query_result.all = MagicMock(return_value=[])
mock_query = MagicMock()
mock_query.filter = MagicMock()
mock_query.filter.return_value = mock_query_result
self._mock_session.query.return_value = mock_query
user = User()
models = self.model_run_service.get_models_for_user(user)
assert_that(len(models), is_(0), "There should be no model for the user")
def test_get_character_name(self):
"""Tests if the get_character_name function behaves as expected.
A fake character is created and mocked out. The database query is
mocked out and the test character is set as the return value of the
query. The test then asserts if the returned character name is the
same as the faked character.
"""
characters = MagicMock()
char = MagicMock()
char.character_name = 'testname'
characters.filter = MagicMock()
characters.filter.return_value = [char]
test = get_character_name(characters)
characters.filter.assert_called_with(is_logged=True)
self.assertEquals(test, 'testname')
def test_delete_private_analysis(self):
mock_query_result = MagicMock()
mock_query_result.one = MagicMock(return_value=self.sample_analysis)
mock_query = MagicMock()
mock_query.filter = MagicMock()
mock_query.filter.return_value = mock_query_result
self._mock_session.query = MagicMock()
self._mock_session.query.return_value = mock_query
analysis_service = AnalysisService(self._mock_session)
analysis_service.delete_private_analysis(self.sample_analysis.id)
self.assertEqual(self.sample_analysis.deleted, True)
def setup(self):
with patch('%s.boto3.resource' % pbm, autospec=True) as m_boto_r:
with patch('%s.boto3.client' % pbm, autospec=True) as m_boto_c:
with patch('%s._encode_key' % pb, autospec=True) as m_ek:
m_ek.return_value = ('key', 'md5')
self.cls = S3Wrapper('bname')
m_k1 = Mock(key='/foo/key/1', name='m_k1')
m_k2 = Mock(key='/foo/key/2', name='m_k2')
m_objects = MagicMock()
m_objects.filter = MagicMock(return_value=[m_k1, m_k2])
m_objects.all = MagicMock(return_value=[m_k1, m_k2])
mock_bucket = Mock()
mock_bucket.objects = m_objects
m_boto_r.return_value.Bucket.return_value = mock_bucket
self.mock_res = m_boto_r
self.mock_client = m_boto_c
def test_publish_analysis(self):
mock_query_result = MagicMock()
mock_query_result.one = MagicMock(return_value=self.sample_analysis)
mock_query = MagicMock()
mock_query.filter = MagicMock()
mock_query.filter.return_value = mock_query_result
self._mock_session.query = MagicMock()
self._mock_session.query.return_value = mock_query
analysis_service = AnalysisService(self._mock_session)
analysis_service.publish_analysis(self.sample_analysis.id)
self.assertEqual(self.sample_analysis.viewable_by, None)
self.assertEqual(self.sample_analysis.result_dataset.viewable_by_user_id, None)
def test_get_datasets_for_user(self):
mock_query_result = MagicMock()
mock_query_result.all = MagicMock()
mock_query = MagicMock()
mock_query.filter = MagicMock()
mock_query.filter.return_value = mock_query_result
self._mock_session.query = MagicMock()
self._mock_session.query.return_value = mock_query
service = DatasetService(self._mock_session)
service.get_datasets_for_user(1234, dataset_type_id=1)
self._mock_session.query.assert_called_once_with(Dataset)
mock_query.filter.assert_called_once_with(ANY, ANY)
mock_query_result.all.assert_called_once_with()
def test_get_model_by_id(self):
""" Test if model can be found by id. Test just checks that the sqlalchemy is called.
"""
mock_query_result = MagicMock()
mock_query_result.one = MagicMock(return_value=self.sample_model)
mock_query = MagicMock()
mock_query.filter = MagicMock()
mock_query.filter.return_value = mock_query_result
self._mock_session.query = MagicMock()
self._mock_session.query.return_value = mock_query
model_service = ModelService(self._mock_session)
model = model_service.get_model_by_id(1)
self.assertEqual(model.id, 1)
self.assertEqual(model.name, 'Test Model')
def test_get_user_by_username(self):
mock_query_result = MagicMock()
mock_query_result.one = MagicMock()
mock_query = MagicMock()
mock_query.filter = MagicMock()
mock_query.filter.return_value = mock_query_result
self._mock_session.query = MagicMock()
self._mock_session.query.return_value = mock_query
username = "******"
user_service = UserService(self._mock_session)
user_service.get_user_by_username(username)
self._mock_session.query.assert_called_once_with(User)
mock_query.filter.assert_called_once_with(ANY)
mock_query_result.one.assert_called_once_with()
def test_walk_ToNode(self):
nw = GraphDSLNodeWalker(self.graphmgr)
node = MagicMock()
node.alias.name = 'alias'
node.filter.query = 'filter'
nw.walk_ToNode(node, [])
self.assertEqual(node.alias, 'alias')
self.assertEqual(node.filter, 'filter')
node = MagicMock()
node.alias.name = 'alias'
node.filter = None
nw.walk_ToNode(node, [])
self.assertEqual(node.alias, 'alias')
self.assertIsNone(node.filter)
def test_auth_resource_show(self, exist_pkg=True, authorized_pkg=True):
#Recover the exception
auth.tk.ObjectNotFound = self._tk.ObjectNotFound
# Mock the calls
package = MagicMock()
package.id = '1'
final_query = MagicMock()
final_query.first = MagicMock(
return_value=package if exist_pkg else None)
second_join = MagicMock()
second_join.filter = MagicMock(return_value=final_query)
first_join = MagicMock()
first_join.join = MagicMock(return_value=second_join)
query = MagicMock()
query.join = MagicMock(return_value=first_join)
model = MagicMock()
session = MagicMock()
session.query = MagicMock(return_value=query)
model.Session = session
# Create the context
context = {}
context['model'] = model
# Mock the package_show function
self._package_show = auth.package_show
success = True if authorized_pkg else False
auth.package_show = MagicMock(return_value={'success': success})
if not exist_pkg:
self.assertRaises(self._tk.ObjectNotFound, auth.resource_show,
context, {})
else:
result = auth.resource_show(context, {})
self.assertEquals(authorized_pkg, result['success'])
def test_auth_resource_show(self, exist_pkg=True, authorized_pkg=True):
#Recover the exception
auth.tk.ObjectNotFound = self._tk.ObjectNotFound
# Mock the calls
package = MagicMock()
package.id = '1'
final_query = MagicMock()
final_query.first = MagicMock(return_value=package if exist_pkg else None)
second_join = MagicMock()
second_join.filter = MagicMock(return_value=final_query)
first_join = MagicMock()
first_join.join = MagicMock(return_value=second_join)
query = MagicMock()
query.join = MagicMock(return_value=first_join)
model = MagicMock()
session = MagicMock()
session.query = MagicMock(return_value=query)
model.Session = session
# Create the context
context = {}
context['model'] = model
# Mock the package_show function
self._package_show = auth.package_show
success = True if authorized_pkg else False
auth.package_show = MagicMock(return_value={'success': success})
if not exist_pkg:
self.assertRaises(self._tk.ObjectNotFound, auth.resource_show, context, {})
else:
result = auth.resource_show(context, {})
self.assertEquals(authorized_pkg, result['success'])
def test_rss_creation(self,
data,
refresh,
resp,
created,
expected_request,
side_effect=None):
# Include data to mock
self.request.raw_post_data = json.dumps(data)
# Mock ExpenditureManager
self.views.ExpenditureManager = MagicMock()
# Mock ModelManager
self.views.ModelManager = MagicMock()
# Create a mock method to manage the token refresh
# if needed
if refresh:
self._exp_mock = ExpenditureMock()
self.views.ExpenditureManager = self._exp_mock.ExpenditureManager
# Create social auth mocks
social_mock = MagicMock()
filter_mock = MagicMock()
object_mock = MagicMock()
object_mock.extra_data = {
'access_token': 'accesstoken',
'refresh_token': 'refreshtoken'
}
filter_mock.return_value = [object_mock]
social_mock.filter = filter_mock
self.request.user.social_auth = social_mock
# Create the corresponding side effect if needed
if side_effect:
side_effect(self)
# Call the view
collection = self.views.RSSCollection(permitted_methods=('GET',
'POST'))
response = collection.create(self.request)
# Check response
val = json.loads(response.content)
self.assertEquals(response.status_code, resp[0])
self.assertEquals(val['message'], resp[1])
self.assertEquals(val['result'], resp[2])
# Check the result depending if the model should
# have been created
if created:
# Check rss call
model_info = None
if 'models' in data:
model_info = data['models']
revenue_model = self._generate_models(model_info)
self.views.RSS.objects.create.assert_called_with(
name=data['name'],
host=data['host'],
api_version=data['api_version'],
expenditure_limits=expected_request,
revenue_models=revenue_model,
aggregator_id=self.user.email)
self.assertEquals(self.rss_object.access_token,
self.user.userprofile.access_token)
views.RSSManagerFactory.assert_called_once_with(self.rss_object)
self.fact_mock.get_expenditure_manager.assert_called_once_with(
self.user.userprofile.access_token)
if not refresh:
self._exp_mock.set_provider_limit.assert_called_once_with()
if data['api_version'] == 2:
self.fact_mock.get_provider_manager.assert_called_once_with(
self.user.userprofile.access_token)
prov_data = {
'provider_id': settings.STORE_NAME.lower() + '-provider',
'provider_name': settings.STORE_NAME + '-Provider'
}
self._prov_mock.register_provider.assert_called_once_with(
prov_data)
else:
self.views.RSS.objects.delete.assert_called_once()
def test_complex_walkthrough(self):
self.expected_nodes = {
'fromfilter': [
{
'_id': 'buzz',
'targets_set': [
'andy:woody',
'andy:rex'
]
},
{
'_id': 'lenny',
'targets_set': []
}
],
'_id:(woody OR rex)': [
{
'_id': 'woody',
'targets_set': [
'andy:sarge'
]
},
{
'_id': 'rex',
'targets_set': [
'andy:sid'
]
}
],
'_id:(sarge OR sid)': [
{
'_id': 'sarge',
'targets_set': []
},
{
'_id': 'sid',
'targets_set': []
}
],
'targets_set:("molly:sarge")': [
{
'_id': 'squeeze',
'targets_set': []
}
],
'targets_set:("molly:sid")': [
{
'_id': 'squeeze',
'targets_set': []
}
],
'targets_set:("molly:squeeze")': [
{
'_id': 'hamm',
'targets_set': []
}
],
'targets_set:("andy:sarge" OR "molly:sarge")': [
{
'_id': 'squeeze',
'targets_set': []
}
],
'targets_set:("andy:sid" OR "molly:sid")': [
{
'_id': 'squeeze',
'targets_set': []
}
],
'targets_set:("andy:squeeze" OR "molly:squeeze")': [
{
'_id': 'hamm',
'targets_set': []
}
],
'targets_set:("molly:hamm")': [
{
'_id': 'bopeep',
'targets_set': []
}
],
'targets_set:("molly:bopeep")': [
{
'_id': 'mrpotato',
'targets_set': []
}
]
}
self.expected_rels = {
'through0filter': [
{'_id': 'andy'},
{'_id': 'molly'}
]
}
from0 = MagicMock()
from0.set_ = 'NODES'
from0.alias = 'elt0'
from0.filter = 'fromfilter'
from1 = MagicMock()
from1.set_ = 'elt0'
from1.alias = 'elt1'
from1.filter = ''
from2 = MagicMock()
from2.set_ = 'elt1'
from2.alias = 'elt2'
from2.filter = '_id:buzz'
statement = MagicMock()
statement.froms = [from0, from1, from2]
path = MagicMock()
through0 = MagicMock()
through0.set_ = 'RELS'
through0.alias = 'rel0'
through0.wmode.type = 'BREADTH'
through0.wmode.begin = 1
through0.wmode.end = None
through0.wmode.direction = 'FORWARD'
through0.filter = 'through0filter'
through1 = MagicMock()
through1.set_ = 'rel0'
through1.alias = 'rel1'
through1.wmode.type = 'DEPTH'
through1.wmode.begin = 1
through1.wmode.end = 2
through1.wmode.direction = 'BACKWARD'
through1.filter = '_id:molly'
through2 = MagicMock()
through2.set_ = 'rel1'
through2.alias = 'rel1'
through2.wmode.type = 'DEPTH'
through2.wmode.begin = 1
through2.wmode.end = 2
through2.wmode.direction = 'BACKWARD'
through2.filter = ''
path.through = [through0, through1, through2]
to0 = MagicMock()
to0.alias = 'elt3'
to0.filter = '_id:mrpotato'
to1 = MagicMock()
to1.alias = 'elt4'
to1.filter = ''
path.to = [to0, to1]
statement.path = [path]
result = self.walk([statement])
self.assertIn('elt0', result)
self.assertIn('elt1', result)
self.assertIn('elt2', result)
self.assertIn('elt3', result)
self.assertIn('elt4', result)
self.assertIn('rel0', result)
self.assertIn('rel1', result)
self.assertEqual(result['elt0']['type'], 'nodes')
self.assertEqual(len(result['elt0']['dataset']), 2)
self.assertIn(
{
'_id': 'buzz',
'targets_set': ['andy:woody', 'andy:rex']
},
result['elt0']['dataset']
)
self.assertIn(
{
'_id': 'lenny',
'targets_set': []
},
result['elt0']['dataset']
)
self.assertEqual(result['elt1']['type'], 'nodes')
self.assertEqual(len(result['elt1']['dataset']), 2)
self.assertIn(
{
'_id': 'buzz',
'targets_set': ['andy:woody', 'andy:rex']
},
result['elt1']['dataset']
)
self.assertIn(
{
'_id': 'lenny',
'targets_set': []
},
result['elt1']['dataset']
)
self.assertEqual(result['elt2']['type'], 'nodes')
self.assertEqual(len(result['elt2']['dataset']), 1)
self.assertIn(
{
'_id': 'buzz',
'targets_set': ['andy:woody', 'andy:rex']
},
result['elt2']['dataset']
)
self.assertEqual(result['elt3']['type'], 'nodes')
self.assertEqual(len(result['elt3']['dataset']), 1)
self.assertIn(
{
'_id': 'mrpotato',
'targets_set': []
},
result['elt3']['dataset']
)
self.assertEqual(result['elt4']['type'], 'nodes')
self.assertEqual(len(result['elt4']['dataset']), 3)
self.assertIn(
{
'_id': 'hamm',
'targets_set': []
},
result['elt4']['dataset']
)
self.assertIn(
{
'_id': 'bopeep',
'targets_set': []
},
result['elt4']['dataset']
)
self.assertIn(
{
'_id': 'mrpotato',
'targets_set': []
},
result['elt4']['dataset']
)
self.assertEqual(result['rel0']['type'], 'relationships')
self.assertEqual(len(result['rel0']['dataset']), 2)
self.assertIn({'_id': 'andy'}, result['rel0']['dataset'])
self.assertIn({'_id': 'molly'}, result['rel0']['dataset'])
self.assertEqual(result['rel1']['type'], 'relationships')
self.assertEqual(len(result['rel1']['dataset']), 1)
self.assertIn({'_id': 'molly'}, result['rel1']['dataset'])
def test_walk_depth_backward(self):
self.expected_nodes = {
'fromfilter': [
{'_id': 'buzz'}
],
'targets_set:("andy:buzz")': [
{'_id': 'woody'},
{'_id': 'rex'}
],
'targets_set:("andy:woody")': [
{'_id': 'sarge'}
],
'targets_set:("andy:rex")': [
{'_id': 'sid'}
],
'targets_set:("andy:sarge")': [],
'targets_set:("andy:sid")': []
}
self.expected_rels = {
'throughfilter': [
{'_id': 'andy'}
]
}
from_ = MagicMock()
from_.set_ = 'NODES'
from_.alias = 'elt0'
from_.filter = 'fromfilter'
statement = MagicMock()
statement.froms = [from_]
path = MagicMock()
through = MagicMock()
through.set_ = 'RELS'
through.alias = 'rel0'
through.wmode.type = 'DEPTH'
through.wmode.begin = 1
through.wmode.end = 2
through.wmode.direction = 'BACKWARD'
through.filter = 'throughfilter'
path.through = [through]
to = MagicMock()
to.alias = 'elt1'
to.filter = '_id:sarge'
path.to = [to]
statement.path = [path]
result = self.walk([statement])
self.assertIn('elt0', result)
self.assertIn('elt1', result)
self.assertIn('rel0', result)
self.assertEqual(result['elt0']['type'], 'nodes')
self.assertEqual(len(result['elt0']['dataset']), 1)
self.assertIn({'_id': 'buzz'}, result['elt0']['dataset'])
self.assertEqual(result['elt1']['type'], 'nodes')
self.assertEqual(len(result['elt1']['dataset']), 1)
self.assertIn({'_id': 'sarge'}, result['elt1']['dataset'])
self.assertEqual(result['rel0']['type'], 'relationships')
self.assertEqual(len(result['rel0']['dataset']), 1)
self.assertIn({'_id': 'andy'}, result['rel0']['dataset'])
def test_rss_creation(self, data, refresh, resp, created, expected_request, side_effect=None):
# Include data to mock
self.request.body = json.dumps(data)
# Mock ExpenditureManager
self.views.ExpenditureManager = MagicMock()
# Mock ModelManager
self.views.ModelManager = MagicMock()
# Create a mock method to manage the token refresh
# if needed
if refresh:
self._exp_mock = ExpenditureMock()
self.views.ExpenditureManager = self._exp_mock.ExpenditureManager
# Create social auth mocks
social_mock = MagicMock()
filter_mock = MagicMock()
object_mock = MagicMock()
object_mock.extra_data = {
'access_token': 'accesstoken',
'refresh_token': 'refreshtoken'
}
filter_mock.return_value = [object_mock]
social_mock.filter = filter_mock
self.request.user.social_auth = social_mock
# Create the corresponding side effect if needed
if side_effect:
side_effect(self)
# Call the view
collection = self.views.RSSCollection(permitted_methods=('GET', 'POST'))
response = collection.create(self.request)
# Check response
val = json.loads(response.content)
self.assertEquals(response.status_code, resp[0])
self.assertEquals(val['message'], resp[1])
self.assertEquals(val['result'], resp[2])
# Check the result depending if the model should
# have been created
if created:
# Check rss call
model_info = None
if 'models' in data:
model_info = data['models']
revenue_model = self._generate_models(model_info)
self.views.RSS.objects.create.assert_called_with(
name=data['name'],
host=data['host'],
api_version=data['api_version'],
expenditure_limits=expected_request,
revenue_models=revenue_model,
aggregator_id=self.user.email
)
self.assertEquals(self.rss_object.access_token, self.user.userprofile.access_token)
views.RSSManagerFactory.assert_called_once_with(self.rss_object)
self.fact_mock.get_expenditure_manager.assert_called_once_with(self.user.userprofile.access_token)
if not refresh:
self._exp_mock.set_provider_limit.assert_called_once_with()
if data['api_version'] == 2:
self.fact_mock.get_provider_manager.assert_called_once_with(self.user.userprofile.access_token)
prov_data = {
'provider_id': settings.STORE_NAME.lower() + '-provider',
'provider_name': settings.STORE_NAME + '-Provider'
}
self._prov_mock.register_provider.assert_called_once_with(prov_data)
else:
self.views.RSS.objects.delete.assert_called_once()
def test_walk_breadth_forward_noend(self):
self.expected_nodes = {
'fromfilter': [
{
'_id': 'buzz',
'targets_set': [
'andy:woody',
'andy:rex'
]
}
],
'_id:(woody OR rex)': [
{
'_id': 'woody',
'targets_set': [
'andy:sarge'
]
},
{
'_id': 'rex',
'targets_set': [
'andy:sid'
]
}
],
'_id:(sarge OR sid)': [
{
'_id': 'sarge',
'targets_set': []
},
{
'_id': 'sid',
'targets_set': []
}
]
}
self.expected_rels = {
'throughfilter': [
{'_id': 'andy'}
]
}
from_ = MagicMock()
from_.set_ = 'NODES'
from_.alias = 'elt0'
from_.filter = 'fromfilter'
statement = MagicMock()
statement.froms = [from_]
path = MagicMock()
through = MagicMock()
through.set_ = 'RELS'
through.alias = 'rel0'
through.wmode.type = 'BREADTH'
through.wmode.begin = 1
through.wmode.end = None
through.wmode.direction = 'FORWARD'
through.filter = 'throughfilter'
path.through = [through]
to = MagicMock()
to.alias = 'elt1'
to.filter = '_id:sarge'
path.to = [to]
statement.path = [path]
result = self.walk([statement])
self.assertIn('elt0', result)
self.assertIn('elt1', result)
self.assertIn('rel0', result)
self.assertEqual(result['elt0']['type'], 'nodes')
self.assertEqual(len(result['elt0']['dataset']), 1)
self.assertIn(
{
'_id': 'buzz',
'targets_set': ['andy:woody', 'andy:rex']
},
result['elt0']['dataset']
)
self.assertEqual(result['elt1']['type'], 'nodes')
self.assertEqual(len(result['elt1']['dataset']), 1)
self.assertIn(
{
'_id': 'sarge',
'targets_set': []
},
result['elt1']['dataset']
)
self.assertEqual(result['rel0']['type'], 'relationships')
self.assertEqual(len(result['rel0']['dataset']), 1)
self.assertIn({'_id': 'andy'}, result['rel0']['dataset'])
