def test_save_data_new_image(self):
"""
Checks whether saving data of a new image creates a new slug
and sets a position
"""
# create a new image
image = models.Image(
image=get_image_in_memory_data(),
position=0,
content_type=ContentType.objects.get_for_model(TestModel),
object_id=self.object.id
)
# use mocks for methods could be called
image._get_slug = mock.MagicMock(return_value='foo')
image._get_position = mock.MagicMock()
image.image.save_files = mock.MagicMock()
# call the _save_data method
image._save_data()
# check whether the _get_slug and the _get_position methods
# have been called
image._get_slug.assert_called_once_with()
image._get_position.assert_called_once_with()
# check whether the save_files method of the image field
# has been called with the slug and the name of the image
image.image.save_files.assert_called_once_with('foo', 'foo.jpg')
def test_get_queryset(self):
"""
Checks whether images in the query set are sorted by position
"""
qs = mock.MagicMock() # mock object returned by parent's method
# create order_by method
qs.order_by = mock.MagicMock(return_value='bar')
# patch parent class to return the mock
with mock.patch(
'django.contrib.contenttypes.admin'
'.GenericInlineModelAdmin.get_queryset',
return_value=qs
) as get_queryset:
# call method being tested with the mock ImageAdminInline
result = admin.ImageAdminInline.get_queryset(
self.inline_admin,
'request'
)
# check whether the parent's method has been called
# with the same argument
get_queryset.assert_called_with('request')
# check whether the order_by method has been called
# with the 'position' str as an argument
qs.order_by.assert_called_with('position')
# check whether the method returns the result of the 'order_by'
self.assertEqual(result, 'bar')
def setUp(self):
"""
Creates a mock object used instead of real form and
a mock for the 'object_id' field
"""
# create a form mock object
self.form = mock.MagicMock(spec=forms.ImageAdminForm)
# 'fields' is a dict
self.form.fields = {}
# create a field mock object
field = mock.MagicMock()
# initially the 'model_class' attribute is None
field.widget.model_class = None
# set the field mock to the form mock
self.form.fields['object_id'] = field
def test_rename_file(self, rename):
"""
Checks whether the _rename_file method calls the os.rename
function with proper arguments
"""
# a mock function to replace the _create_filename method
mock_func = mock.MagicMock(return_value='baz_bar.jpg')
self.image_file._create_filename = mock_func
# set original path
self.image_file.path = 'gallery/foo_bar.jpg'
# patch the create_path helper function to return a new path
with mock.patch.object(
utils,
'create_path',
return_value='gallery/baz_bar.jpg'
) as create_path:
# call the _rename_files method with a new file name
image_data.ImageFile._rename_file(self.image_file, 'baz.jpg')
# check whether the helper function has been called
# with the result of the _create_filename method
create_path.assert_called_with('baz_bar.jpg')
# check whether the mock _create_filename method has been called
# with the new file name
mock_func.assert_called_with('baz.jpg')
# check whether the os.rename function has been called
# with the original and the new paths
rename.assert_called_with(
'gallery/foo_bar.jpg',
'gallery/baz_bar.jpg'
)
def test_render_with_image(self, render_to_string):
"""
Checks whether the render method returns a result of
the render_to_string function if the method has been
called with an image
"""
# set a template name
self.widget.template_name = "bar"
# create an image mock
image = mock.MagicMock()
# set an URL of the small preview
image.small_preview_url = 'url'
# patch the create_image_url so that it returns known result
with mock.patch.object(utils, 'create_image_data',
return_value='data') as create_data:
# call the method with the image mock
result = widgets.ImageInlineWidget.render(self.widget, 'name',
image)
# check whether the create_image_data helper function has been
# called with the image
create_data.assert_called_with(image)
# check whether the method returns the result of
# the render_to_string function
self.assertEqual(result, "foo")
# check whether the render_to_string function has been called
# with proper arguments
render_to_string.assert_called_with(
'bar', # the template name
{
'preview_src': 'url', # the URL of small preview
# the result of the create_image_data function
# in JSON format
'image_data': json.dumps('data')
})
def test_render_with_mark_safe(self, mark_safe):
"""
Checks whether the widget is rendered properly
"""
# create a mock widget object
widget = mock.MagicMock(spec=widgets.ContentTypeSelect)
# set the js template
# it should contain %s for URL pattern subtitution
widget.js = " %s"
# patch the get_choices_url_pattern helper function
# so that it returns known value
with mock.patch.object(
utils, 'get_choices_url_pattern',
return_value='foo') as get_url_pattern, mock.patch.object(
Select, # patch parent's method
'render',
return_value='bar') as render:
# call the render method
result = widgets.ContentTypeSelect.render(widget, 'name', 'value')
# check whether the helper function has been called
get_url_pattern.assert_called_with()
# check whether the parent's method has been called
# with the same arguments
render.assert_called_with('name', 'value', None)
# check whether the mark_safe function has been called with rendered
# template containing a result of the parent's method + the js
# pattern where %s is replaced with the URL pattern
# i.e. 'bar' + ' %s' % 'foo'
mark_safe.assert_called_with('bar foo')
# check whether the render method returns a result of the mark_safe
self.assertEqual(result, "baz")
def setUpClass(cls):
"""
Creates two objects of the TestModel in the database
"""
cls.widget = mock.MagicMock(spec=widgets.ObjectIdSelect)
cls.object1 = TestModel.objects.create(name="Test object 1")
cls.object2 = TestModel.objects.create(name="Test object 2")
def setUp(self):
"""
Creates a new mock Image object for each test
Sets a known name of the image
"""
self.image = mock.MagicMock(spec=models.Image)
self.image.name = 'gallery/foo.jpg'
def setUp(self):
"""
Creates a GalleryImageFieldFile object with known values
for each test. Saves used mocks of the InMemoryImageData
and ImageFile classes.
"""
super().setUp()
# patch classes used to manipulate with image data
with mock.patch.object(image_data, 'InMemoryImageData') as m:
with mock.patch.object(image_data, 'ImageFile') as f:
# set known settings
with patch_settings({
'image_width': 1024,
'image_height': 768,
'small_image_width': 800,
'small_image_height': 600,
'preview_width': 400,
'preview_height': 300,
'small_preview_width': 200,
'small_preview_height': 150,
'thumbnail_width': 120,
'thumbnail_height': 80
}):
# create the object
self.field_file = fields.GalleryImageFieldFile(
self.image, mock.MagicMock(), str(self.image))
# save mocks of called classes
self.image_file = f
self.in_memory_data = m
def test_save_files_image_data_does_not_exist(self):
"""
Checks whether save methods of image objects are
called properly and the name has been set to the
name in the database
"""
# replace creation of the directory
self.field_file._check_dir = mock.MagicMock()
# data does not exist
self.field_file.image_data.data = None
# set known name in the database
self.field_file.image_data.name_in_db = 'foo'
# call the method with known arguments
self.field_file.save_files('bar', 'baz')
# check whether the _check_dir has been called
self.field_file._check_dir.assert_called_with()
# check whether the save methods of all image objects
# has been called with the arguments passed to tested method
self.field_file.image_data.save.assert_called_with(
self.field_file, 'bar', 'baz')
self.field_file.thumbnail.save.assert_called_with(
self.field_file, 'bar', 'baz')
self.field_file.preview.save.assert_called_with(
self.field_file, 'bar', 'baz')
self.field_file.small_preview.save.assert_called_with(
self.field_file, 'bar', 'baz')
self.field_file.small_image.save.assert_called_with(
self.field_file, 'bar', 'baz')
# check whether the name has been set to the name in the database
self.assertEqual(self.field_file.name, 'foo')
def test_get_formset(self):
"""
Checks whether the formset has the 'preview_url_pattern'
attribute containing the URL pattern
"""
# the mock object returned by parent's method
formset = mock.MagicMock()
# patch parent class to return the mock
with mock.patch(
'django.contrib.contenttypes.admin'
'.GenericInlineModelAdmin.get_formset',
return_value=formset
# patch the helper function to return known value
) as get_formset, mock.patch.object(
utils,
'get_admin_new_image_preview_url_pattern',
return_value='url_pattern'
) as get_pattern:
# call the method being tested with the mock ImageAdminInline
result = admin.ImageAdminInline.get_formset(
self.inline_admin,
'request'
)
# check whether parent's method has been called
# with the same argument
get_formset.assert_called_with('request', None)
# check whether the helper function has been called
get_pattern.assert_called_with()
# check whether the method returns the result of parent's method
self.assertEqual(formset, result)
# check whether the 'preview_url_pattern' of returned object
# has the correct value
self.assertEqual(formset.preview_url_pattern, 'url_pattern')
def test_filter_choices(self):
"""
Checks whether the _filter_choices method removes from
the choices list all models unless it has the gallery_visible
attribute with True value. Also an empty choice should remain
"""
# create a choice of TestModel (gallery_visible=True)
ctype = ContentType.objects.get_for_model(TestModel)
test_choice = (str(ctype.pk), ctype.name)
# create a choice of AnotherTestModel (gallery_visible=False)
ctype = ContentType.objects.get_for_model(AnotherTestModel)
another_choice = (str(ctype.pk), ctype.name)
# create a choice of WrongTestModel (has not gallery_visible)
ctype = ContentType.objects.get_for_model(WrongTestModel)
wrong_choice = (str(ctype.pk), ctype.name)
# create a mock widget object
widget = mock.MagicMock(spec=widgets.ContentTypeSelect)
# set initial choices
widget.choices = [("", "----"), test_choice, another_choice,
wrong_choice]
# call the _filter_choices method
widgets.ContentTypeSelect._filter_choices(widget)
# check whether an empty choice is in the list
self.assertIn(("", "----"), widget.choices)
# check whether the TestModel choice is in the list
self.assertIn(test_choice, widget.choices)
# check whether the AnotherTestModel choice is not in the list
self.assertNotIn(another_choice, widget.choices)
# check whether the WrongTestModel choice is not in the list
self.assertNotIn(wrong_choice, widget.choices)
def test_create_image_data(self):
"""
Checks whether the create_image_data function returns
correct data
"""
# create a mock image with known values of the urls
image = mock.MagicMock()
image.image_url = 'foo'
image.small_image_url = 'bar'
# patch settings so that set known sizes
with patch_settings({
'image_width': 1024,
'image_height': 768,
'small_image_width': 800,
'small_image_height': 600
}):
# call the create_image_data function
data = utils.create_image_data(image)
# check whether the full-size image URL is correct
self.assertEqual(data['image']['url'], 'foo')
# check whether the full-size image size is correct
self.assertEqual(data['image']['width'], 1024)
self.assertEqual(data['image']['height'], 768)
# check whether the small image URL is correct
self.assertEqual(data['small_image']['url'], 'bar')
# check whether the small image size is correct
self.assertEqual(data['small_image']['width'], 800)
self.assertEqual(data['small_image']['height'], 600)
def setUp(self):
self.scrapy = ScrapyCtl(accounts={}, loglevel='ERROR')
self.command = Command()
self.command.stdout = mock.MagicMock()
self.all_spiders = [
'mangareader', 'unionmangas', 'kissmanga', 'batoto', 'mangahere',
'mangafox', 'mangasee'
]
def test_render_with_image(self, escape):
"""
Checks whether the template_with_initial is filled properly
if the render method has been called with saved image
"""
# set initial template_with_initial value
self.widget.template = "{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}"
# create a mock image field file object
image = mock.MagicMock(spec=fields.GalleryImageFieldFile)
# set known settings and patch helper functions
with patch_settings({
'preview_width': 400,
'preview_height': 300,
}), mock.patch.object(
utils, 'create_image_data',
return_value='data') as create_data, mock.patch.object(
utils, 'create_static_url',
return_value='url') as create_url, mock.patch.object(
AdminFileWidget, # patch the parent's render method
'render',
return_value='foo') as render:
# call the method with an image field file mock
result = widgets.ImageWidget.render(self.widget, 'name', image)
# check whether the parent's method has been called
# with the same arguments
render.assert_called_with('name', image, None)
# check whether tha create_static_url helper function has been
# called with the path to zoom image
create_url.assert_called_with("content_gallery/img/zoom.png")
# check whether the create_image_data helper function has been
# called with the image filed file mock
create_data.assert_called_with(image)
# check whether the escape has been called with the returned by
# create_image_data value in JSON format
escape.assert_called_with(json.dumps('data'))
# check whether the method returns the result of the parent's method
self.assertEqual(result, 'foo')
# check whether the template has been filled properly
self.assertEqual(
self.widget.template_with_initial,
"\n".join([
# the size of the container
str(400 + 14),
str(300 + 14),
# the size of the image
str(400),
str(300),
# the line-height
str(300),
# the result of the escape function
"escaped data",
# the result of create_static_url function
"url",
# the left offset of the zoom image
str(400 - 55)
]))
def test_get_mole_image_prediction_failed(self, mock_requests):
post_mock = mock.MagicMock()
post_mock.json.return_value = {
'status': 'error',
}
mock_requests.post.return_value = post_mock
# Task `get_mole_image_prediction` runs automatically on post save
# signal
with self.fake_media(), self.assertRaises(GetPredictionError):
MoleImageFactory.create(photo=self.get_sample_image_file())
def test_set_up(self, mock_requests):
post_mock = mock.MagicMock()
post_mock.json.return_value = {
'status': 'success',
'probability': 0.567,
'prediction': 'Seems benign',
}
mock_requests.post.return_value = post_mock
with self.fake_media():
MoleImageFactory.create(photo=self.get_sample_image_file())
self.assertTrue(mock_requests.post.called)
def test_save_data_unchanged_image(self):
"""
Checks whether saving data of an unchanged image does not call
the _get_slug and _get_position methods
"""
# use mocks for methods could be called
self.image._get_slug = mock.MagicMock()
self.image._get_position = mock.MagicMock()
self.image.image.save_files = mock.MagicMock()
self.image._object_changed = mock.MagicMock(return_value=False)
# call the _save_data method
self.image._save_data()
# check whether the _get_slug and _get_position methods
# has not been called
self.image._get_slug.assert_not_called()
self.image._get_position.assert_not_called()
# get a name of the image
name = self.get_name('foo.jpg')
# check whether the save_files method of the image field
# has been called with empty slug and the name of the image
self.image.image.save_files.assert_called_once_with('', name)
def test_delete_files_image(self):
"""
Checks whether the delete_files method calls the delete_files
method of the image field
"""
# set a mock to the method could be called
self.image.image.delete_files = mock.MagicMock()
# call the delete_files method
self.image.delete_files()
# check whether the delete_files method of the image field
# has been called
self.image.image.delete_files.assert_called_once_with()
def test_delete(self):
"""
Tests whether the delete method calls the delete_files
methods of all contained objects
"""
# create two mock objects
obj1 = mock.MagicMock()
obj2 = mock.MagicMock()
# create a mock query set object
query_set = mock.MagicMock(spec=models.ImageQuerySet)
# the query set iteration yields objects created before
query_set.__iter__.return_value = [obj1, obj2]
# patch the delete method of the parent class
with mock.patch('django.db.models.QuerySet.delete') as delete:
# call the delete method
models.ImageQuerySet.delete(query_set)
# check whether the parent's delete method has been called
delete.assert_called_with()
# check whether the delete_files methods
# of both objects have been called
obj1.delete_files.assert_called_with()
obj2.delete_files.assert_called_with()
def test_save_data_changed_image(self):
"""
Checks whether saving data of a changed image creates a new slug
and sets a position
"""
# use mocks for methods could be called
self.image._get_slug = mock.MagicMock(return_value='foo')
self.image._get_position = mock.MagicMock()
self.image.image.save_files = mock.MagicMock()
# object_changed should return True
self.image._object_changed = mock.MagicMock(return_value=True)
# call the _save_data method
self.image._save_data()
# check whether the _get_slug and the _get_position methods
# have been called
self.image._get_slug.assert_called_once_with()
self.image._get_position.assert_called_once_with()
# get a name of the image
name = self.get_name('foo.jpg')
# check whether the save_files method of the image field
# has been called with a new slug and the name of the image
self.image.image.save_files.assert_called_once_with('foo', name)
def test_small_preview_url_property(self):
"""
Checks whether the small_preview_url property returns a result
of the small_preview_url property of the image field
"""
# mock the image field and set the small_preview_url value
image_mock = mock.MagicMock()
image_mock.small_preview_url = 'foo'
# patch the image object
with mock.patch.object(self.image, 'image', image_mock):
# check whether the small_preview_url property returns
# a value of the small_preview_url of the mock
self.assertEqual(self.image.small_preview_url, 'foo')
def test_cursor_close_failure_does_not_mask_original_exception(self):
persons = Person.objects.iterator()
def raise_original_exception(*args, **kwargs):
raise Exception(
'Real exception raised by the database on cursor.execute')
def raise_close_exception():
raise Exception(
'Error when attempting to close the cursor, this exception should not mask the original exception'
)
mock_cursor = connection.chunked_cursor()
mock_cursor.execute = mock.MagicMock(
side_effect=raise_original_exception)
mock_cursor.close = mock.MagicMock(side_effect=raise_close_exception)
with self.assertRaisesMessage(
Exception,
'Real exception raised by the database on cursor.execute'):
with mock.patch('django.db.connection.create_cursor',
return_value=mock_cursor):
list(persons)
def test_get_mole_image_prediction_success(self, mock_requests):
post_mock = mock.MagicMock()
post_mock.json.return_value = {
'status': 'success',
'probability': 0.567,
'prediction': 'Seems benign',
}
mock_requests.post.return_value = post_mock
# Task `get_mole_image_prediction` runs automatically on post save
# signal
with self.fake_media():
mole_image = MoleImageFactory.create(
photo=self.get_sample_image_file())
mole_image.refresh_from_db()
self.assertEqual(mole_image.prediction, 'Seems benign')
self.assertAlmostEqual(float(mole_image.prediction_accuracy), 0.567)
def test_filename_property(self):
"""
Checks whether the filename property returns a result of
the _create_filename method called with the name as an argument
"""
# set a name
self.image_file.name = 'bar'
# create a mock for the method
mock_func = mock.MagicMock(return_value='foo')
# set the mock to the _create_filename attribute
self.image_file._create_filename = mock_func
# check whether the property returns a result of
# the _create_filename method
self.assertEqual(
image_data.ImageFile.filename.fget(self.image_file),
'foo'
)
# check whether the _create_filename method has been called
# with the name as an argument
mock_func.assert_called_with('bar')
def test_render_with_uploaded_image(self):
"""
Checks whether the template_with_initial is not affected by
the render method if it has been called with just uploaded image
"""
# set initial template_with_initial value
self.widget.template_with_initial = "bar"
# create a mock object of just uploaded image
image = mock.MagicMock(spec=InMemoryUploadedFile)
# patch the parent's render method
with mock.patch.object(AdminFileWidget, 'render',
return_value='foo') as render:
# call the method with just uploaded image mock
result = widgets.ImageWidget.render(self.widget, 'name', image)
# check whether the parent's method has been called
# with the same arguments
render.assert_called_with('name', image, None)
# check whether the method returns the result of the parent's method
self.assertEqual(result, 'foo')
# check whether the template_with_initial has not been changed
self.assertEqual(self.widget.template_with_initial, 'bar')
def setUp(self):
"""
Creates a mock widget object
"""
self.widget = mock.MagicMock(spec=widgets.ImageInlineWidget)
def setUp(self):
"""
Creates a mock object passed to methods of
the ImageAdminInline for each test
"""
self.inline_admin = mock.MagicMock(spec=admin.ImageAdminInline)
def setUp(self):
"""
Creates a new mock InMemoryImageData object for each test
"""
super().setUp()
self.memory_data = mock.MagicMock(spec=image_data.InMemoryImageData)
def setUp(self):
"""
Creates a new mock ImageFile object for each test
"""
super().setUp()
self.image_file = mock.MagicMock(spec=image_data.ImageFile)
