def test_multiple_context_hints_w_multiple_select_related_multiple_prefetch_related(
self):
source = N(models.Source, id=1)
source2 = N(models.Source, id=2)
qsets = context_loader.get_querysets_for_context_hints({
source: {
'key': {
'app_name': 'tests',
'model_name': 'TestModel',
'select_related': ['fk'],
'prefetch_related': ['fk_m2m'],
},
},
source2: {
'key2': {
'app_name': 'tests',
'model_name': 'TestModel',
'select_related': ['fk2'],
},
}
})
# Create objects to query in order to test optimal number of queries
fk = G(test_models.TestFKModel)
fk2 = G(test_models.TestFKModel2)
o = G(test_models.TestModel, fk=fk, fk2=fk2)
m2ms = [G(test_models.TestFKModel), G(test_models.TestFKModel)]
o.fk_m2m.add(*m2ms)
with self.assertNumQueries(2):
v = qsets[test_models.TestModel].get(id=o.id)
self.assertEquals(v.fk, fk)
self.assertEquals(v.fk2, fk2)
self.assertEquals(set(v.fk_m2m.all()), set(m2ms))
def test_multiple_context_hints_w_multiple_select_related(self):
source = N(models.Source, id=1)
source2 = N(models.Source, id=2)
qsets = context_loader.get_querysets_for_context_hints({
source: {
'key': {
'app_name': 'tests',
'model_name': 'TestModel',
'select_related': ['fk'],
},
},
source2: {
'key2': {
'app_name': 'tests',
'model_name': 'TestModel',
'select_related': ['fk2'],
},
}
})
# Verify the raw sql to ensure select relateds will happen
expected_sql = (
'SELECT "tests_testmodel"."id", "tests_testmodel"."value", "tests_testmodel"."fk_id", '
'"tests_testmodel"."fk2_id", '
'"tests_testfkmodel"."id", "tests_testfkmodel"."value", '
'"tests_testfkmodel2"."id", "tests_testfkmodel2"."value" FROM "tests_testmodel" INNER JOIN '
'"tests_testfkmodel" ON ("tests_testmodel"."fk_id" = "tests_testfkmodel"."id") '
'INNER JOIN "tests_testfkmodel2" ON ("tests_testmodel"."fk2_id" = "tests_testfkmodel2"."id")'
)
actual_sql = str(qsets[test_models.TestModel].query)
# Django < 1.7 and 1.8 have spaces before/after parentheses
actual_sql = actual_sql.replace('( ', '(').replace(' )', ')')
self.assertEquals(actual_sql, expected_sql)
def test_result_monitor_get_data_contains_serialised_result(self):
log_frame = N(LogFrame, id=1)
result = N(Result, ignore_fields=['log_frame', 'parent', 'rating', 'risk_rating'])
result.log_frame = log_frame
result_monitor_view = ResultMonitor()
result_monitor_view.object = result
expected_data = {
'id': result.id,
'name': result.name,
'description': result.description,
'order': result.order,
'parent': None,
'level': result.level,
'contribution_weighting': result.contribution_weighting,
'risk_rating': None,
'rating': None,
'log_frame': log_frame.id,
'indicators': [],
'activities': [],
'assumptions': []
}
actual_data = result_monitor_view.get_data(log_frame, {})
assert expected_data == actual_data['result']
def test_one_context_renderer(self, mock_get_sources):
source = N(models.Source, id=1)
mock_get_sources.return_value = [source]
res = context_loader.get_context_hints_per_source([
N(models.ContextRenderer,
source=source,
context_hints={
'key': {
'app_name': 'entity_event.tests',
'model_name': 'TestModel',
'select_related': ['fk'],
},
})
])
self.assertEquals(
res, {
source: {
'key': {
'app_name': 'entity_event.tests',
'model_name': 'TestModel',
'select_related': set(['fk']),
'prefetch_related': set(),
}
}
})
def test_group(self, subscribed_mock):
source = N(Source)
medium = N(Medium)
entity = N(Entity)
ct = N(ContentType)
Subscription.objects.is_subscribed(source, medium, entity, ct)
self.assertEqual(len(subscribed_mock.mock_calls), 1)
def test_multiple_context_renderers_over_multiple_source(self):
source1 = N(models.Source, id=1)
source2 = N(models.Source, id=2)
res = context_loader.get_context_hints_per_source([
N(models.ContextRenderer,
source=source1,
context_hints={
'key': {
'app_name': 'entity_event.tests',
'model_name': 'TestModel',
'select_related': ['fk'],
'prefetch_related': ['prefetch1', 'prefetch2'],
},
}),
N(models.ContextRenderer,
source=source1,
context_hints={
'key': {
'app_name': 'entity_event.tests',
'model_name': 'TestModel',
'select_related': ['fk1'],
'prefetch_related': ['prefetch2', 'prefetch3'],
},
}),
N(models.ContextRenderer,
source=source2,
context_hints={
'key2': {
'app_name': 'entity_event.tests2',
'model_name': 'TestModel2',
'select_related': ['fk2'],
'prefetch_related': ['prefetch5', 'prefetch6'],
},
})
])
self.assertEquals(
res, {
source1: {
'key': {
'app_name':
'entity_event.tests',
'model_name':
'TestModel',
'select_related':
set(['fk', 'fk1']),
'prefetch_related':
set(['prefetch1', 'prefetch2', 'prefetch3']),
}
},
source2: {
'key2': {
'app_name': 'entity_event.tests2',
'model_name': 'TestModel2',
'select_related': set(['fk2']),
'prefetch_related': set(['prefetch5', 'prefetch6']),
}
},
})
def setUp(self):
person_kind = G(EntityKind, name='person', display_name='person')
superentity = G(Entity)
sub1, sub2 = G(Entity, entity_kind=person_kind), G(Entity, entity_kind=person_kind)
G(EntityRelationship, super_entity=superentity, sub_entity=sub1)
G(EntityRelationship, super_entity=superentity, sub_entity=sub2)
self.group_sub = N(Subscription, entity=superentity, sub_entity_kind=person_kind)
self.indiv_sub = N(Subscription, entity=superentity, sub_entity_kind=None)
def test_message_required_if_user_not_already_observing(self):
user_1 = N(User, id=1)
decision = N(Decision, author=user_1, editor=user_1, id=1)
self.assertTrue(
additional_message_required(
user_1, decision, FEEDBACK_MAJOR_CHANGES
)
)
def test_message_not_required_if_feedback_major_notification_user_watches_adds_comment(self):
user_1 = N(User, id=1)
decision = N(Decision, author=user_1, editor=user_1, id=1)
self.assertFalse(
additional_message_required(
user_1, decision, FEEDBACK_MAJOR_CHANGES
)
)
def test_message_required_if_major_changes_only_user_watches_adds_comment(self):
user_1 = N(User, id=1)
decision = N(Decision, author=user_1, editor=user_1, id=1)
decision.watchers = []
self.assertTrue(
additional_message_required(
user_1, decision, FEEDBACK_MAJOR_CHANGES
)
)
def test_unicode(self):
"""
Tests the model's unicode method
"""
tag_value = N(TagValue,
tag=N(Tag,
name='test tag',
game=N(Game, name='test game')),
name='test tag value')
self.assertEqual('test tag: test tag value (test game)',
unicode(tag_value))
def test_remove_watcher_view_removes_observer_from_item(
self, notifications):
decision = N(Decision)
user = N(User)
mock_view = MagicMock(spec=RemoveWatcher)
mock_view.get_object = lambda: decision
mock_view.get_user = lambda: user
mock_view.get = RemoveWatcher.get
mock_view.get(mock_view, RequestFactory().get('/', {'next': '/'}))
notifications.stop_observing.assert_called_with(decision, user)
def test_w_one_event_one_context_hint_list_pks(self):
source = N(models.Source, id=1)
hints = {
source: {
'key': {
'app_name': 'tests',
'model_name': 'TestModel',
},
},
}
e = N(models.Event, context={'key': [2, 3, 5]}, source=source)
self.assertEquals(context_loader.get_model_ids_to_fetch([e], hints),
{test_models.TestModel: set([2, 3, 5])})
def setUp(self):
self.medium = N(Medium, display_name='Test Medium')
self.source = N(Source, display_name='Test Source')
self.source_group = N(SourceGroup, display_name='Test Source Group')
self.entity = N(Entity, display_name='Test Entity')
self.entity_string = text_type(self.entity)
self.unsubscription = N(Unsubscription, entity=self.entity, medium=self.medium, source=self.source)
self.subscription = N(Subscription, entity=self.entity, source=self.source, medium=self.medium)
self.event = N(Event, source=self.source, context={}, id=1)
self.event_actor = N(EventActor, event=self.event, entity=self.entity)
self.event_seen = N(EventSeen, event=self.event, medium=self.medium, time_seen=datetime(2014, 1, 2))
def test_result_data(self):
result = G(Result, manifest=MANIFEST())
testjob = N(TestJob, result=result, status='Complete')
test_results = [
{
'benchmark_name':
'bar',
'subscore': [
{
'name': 'test1',
'measurement': 1
},
{
'name': 'test1',
'measurement': 2
},
]
},
]
store_testjob_data(testjob, test_results)
self.assertEqual(TestJob.objects.count(), 1)
self.assertEqual(Benchmark.objects.count(), 1)
self.assertEqual(ResultData.objects.count(), 1)
result_data = ResultData.objects.order_by('id').last()
self.assertEqual(result_data.values, [1, 2])
self.assertEqual(result_data.benchmark.name, 'bar')
def setUp(self):
self.medium = N(Medium)
self.superentity = G(Entity)
self.sub1, self.sub2 = G(Entity), G(Entity)
self.random_entity = G(Entity)
G(EntityRelationship, super_entity=self.superentity, sub_entity=self.sub1)
G(EntityRelationship, super_entity=self.superentity, sub_entity=self.sub2)
def test_text_path(self, open_mock):
open_mock.return_value.__enter__.return_value.read.return_value = 'Hi {{ name }}'
template = G(EmailTemplate, text_template_path='NotNothing')
email = N(Email, template=template, context={'name': 'Mr. T'})
rendered_text, rendered_html = tasks.render_templates(email)
self.assertEqual(rendered_text, 'Hi Mr. T')
self.assertEqual(rendered_html, '')
def test_random(self):
instance = N('django_dynamic_fixture.ModelWithNumbers',
data_fixture='random')
assert instance is not None
instance = G('django_dynamic_fixture.ModelWithNumbers',
data_fixture='random')
assert instance is not None
def test_test_textfield(self):
temp = '<html>Hi {{ name }}</html>'
template = G(EmailTemplate, html_template=temp)
email = N(Email, template=template, context={'name': 'Mr. T'})
rendered_text, rendered_html = tasks.render_templates(email)
self.assertEqual(rendered_text, '')
self.assertEqual(rendered_html, '<html>Hi Mr. T</html>')
def test_bulk_create_update(self):
es = [N(Entity, is_active=True) for i in range(3)]
t1 = datetime.utcnow()
Entity.objects.bulk_create(es)
t2 = datetime.utcnow()
es = list(Entity.objects.order_by('id'))
Entity.objects.update(is_active=False)
t3 = datetime.utcnow()
events = list(EntityActivationEvent.objects.all())
self.assertTrue(len(events), 6)
for i in range(3):
self.assertEquals(events[i].entity, es[i])
self.assertTrue(t1 <= events[i].time <= t2)
self.assertTrue(events[i].was_activated)
# The entities deactivation order is dependent on the DB. Populate
# all deactivated entities and verify they are the same as the entities
deactivated = []
for i in range(3, 6):
self.assertTrue(t2 <= events[i].time <= t3)
self.assertFalse(events[i].was_activated)
deactivated.append(events[i].entity)
self.assertEquals(set(deactivated), set(es))
def test_add_watcher_view_adds_observer_to_item(self, notifications):
# A watcher is only added if the item isn't already being watched so we
# explicitly set is_observing to False
notifications.is_observing = lambda decision, user: False
decision = N(Decision)
user = N(User)
mock_view = MagicMock(spec=AddWatcher)
mock_view.get_object = lambda: decision
mock_view.get_user = lambda: user
mock_view.get = AddWatcher.get
mock_view.get(mock_view, RequestFactory().get('/', {'next': '/'}))
notifications.observe.assert_called_with(decision, user,
DECISION_CHANGE)
def test_static_sequential(self):
instance = N('django_dynamic_fixture.ModelWithNumbers',
data_fixture='static_sequential')
assert instance is not None
instance = G('django_dynamic_fixture.ModelWithNumbers',
data_fixture='static_sequential')
assert instance is not None
def test_n(self):
foo = N(Foo, char_field='foo')
foo.char_field = 'bar'
foo.save()
foo.char_field = 'baz'
foo.save()
self.assertEqual(foo.char_field_delta_count, 1)
def test_update_session_logframe_updates_user_last_viewed_logframe():
request = mock.Mock(user=MockUser())
logframe = N(LogFrame, slug='test_slug')
update_last_viewed_logframe(request.user, logframe)
assert 'test_slug' == request.user.preferences.last_viewed_logframe.slug
def test_result_data_with_benchmark_group(self):
result = G(Result, manifest=MANIFEST())
testjob = N(TestJob, result=result, status='Complete')
test_results = [
{
'benchmark_group':
'foo',
'benchmark_name':
'bar',
'subscore': [
{
'name': 'test1',
'measurement': 1
},
{
'name': 'test1',
'measurement': 2
},
]
},
]
store_testjob_data(testjob, test_results)
self.assertEqual(BenchmarkGroup.objects.count(), 2) # foo + /
benchmark_group = BenchmarkGroup.objects.order_by('id').last()
benchmark = Benchmark.objects.order_by('id').last()
self.assertEqual(benchmark.group, benchmark_group)
def test_queryset(self):
am = G(TestModel)
am2 = G(TestModel)
ma = N(ModelAssertion,
model_type=ContentType.objects.get_for_model(TestModel))
self.assertEqual(set(ma.queryset), set([am, am2]))
def test_one_event_w_model_data(self):
m = N(test_models.TestModel, id=2)
s = N(models.Source, id=1)
hints = {
s: {
'key': {
'model_name': 'TestModel',
'app_name': 'tests',
}
}
}
e = N(models.Event, context={'key': m.id}, source=s)
context_loader.load_fetched_objects_into_contexts(
[e], {test_models.TestModel: {
m.id: m
}}, hints)
self.assertEquals(e.context, {'key': m})
def test_custom_one(self):
from django_dynamic_fixture.fixture_algorithms.sequential_fixture import SequentialDataFixture
instance = N('django_dynamic_fixture.ModelWithNumbers',
data_fixture=SequentialDataFixture())
assert instance is not None
instance = G('django_dynamic_fixture.ModelWithNumbers',
data_fixture=SequentialDataFixture())
assert instance is not None
def test_empty_backup_exception(self):
backup = N(Backup, fill_nullable_fields=False)
try:
backup.run()
except EmptyBackupException:
pass
else:
self.fail("should raise an EmptyBackupException")
def test_get_user_looks_for_user_in_request(self):
user = N(User)
request = RequestFactory().get('')
request.user = user
view = AddWatcher()
view.request = request
self.assertEqual(user, view.get_user())
