test_thumbnail.py

# encoding: utf-8

import os
import os.path as path
from mock import patch, Mock, call
import nose.tools as nt
from ckan.common import config

import ckanext.odsh.pdf_to_thumbnail.thumbnail as thumbnail
import ckanext.odsh.tests_tpsh.thumbnail_patches as p


class TestCreateThumbnailFromFile(p.WithTempFolder):
    
    def test_pass(self):
        pass

    def test_thumbnail_for_test_pdf(self):
        with open(os.path.join(p.resources_path, 'test.pdf')) as f:
            filename_thumbnail = thumbnail._create_thumbnail_from_file(f)
            nt.assert_true(path.exists(
                path.join(p.thumbnail_folder, filename_thumbnail)
            ))
    
    def test_thumbnail_for_ki_strategie(self):
        with open(os.path.join(p.resources_path, 'ki_strategie.pdf')) as f:
            thumbnail._create_thumbnail_from_file(f)
    

class TestGetFilepathToResource(p.WithTempFolder):

    def test_it_returns_correct_path(self):
        resource = {
            'id': '3F2504E0-4F89-11D3-9A0C-0305E82C3301'
        }
        filepath = thumbnail.get_resource_path(resource)
        filepath_expected = os.path.join(
            p.temp_path, 'resources/3F2/504/E0-4F89-11D3-9A0C-0305E82C3301')
        nt.assert_equal(filepath, filepath_expected)
    


class TestChangeFilepath(p.WithTempFolder):

    def test_renames_thumbnail(self):
        open(os.path.join(p.thumbnail_folder, 'some_filename'), 'a').close()
        thumbnail.rename_thumbnail_to_random_name('some_filename')
        thumbnails = os.listdir(p.thumbnail_folder)
        nt.assert_equal(len(thumbnails), 1)
        filename = thumbnails[0]
        nt.assert_true(filename.startswith('thumbnail_picture_'))
        nt.assert_true(filename.endswith('.jpg'))


class TestIsPdf(object):

    def test_true_for_pdf(self):
        filepath = os.path.join(p.resources_path, 'test.pdf')
        is_pdf = thumbnail._is_pdf(filepath)
        nt.assert_true(is_pdf)
    
    def test_false_for_text_file(self):
        filepath = os.path.join(p.resources_path, 'transparenz.rdf')
        is_pdf = thumbnail._is_pdf(filepath)
        nt.assert_false(is_pdf)


class TestCreateThumbnailFromMemory(p.WithTempFolder):

    @p.patch_get_resource_path
    def test_creates_thumbnail_for_pdf(self, _patch):
        is_pdf, filename = thumbnail._create_thumbnail_from_memory(dict(), '')
        nt.assert_true(filename.startswith('thumbnail_picture_'))
        nt.assert_true(filename.endswith('.jpg'))
        nt.assert_true(is_pdf)
        nt.assert_true(os.path.exists(os.path.join(p.thumbnail_folder, filename)))

    @p.patch_get_resource_path
    def test_removes_old_thumbnail(self, _patch):
        open(os.path.join(p.thumbnail_folder, 'old_thumbnail.jpg'), 'a').close()
        thumbnail._create_thumbnail_from_memory(dict(), 'old_thumbnail')
        thumbnails = os.listdir(p.thumbnail_folder)
        nt.assert_equal(len(thumbnails), 1)
        nt.assert_not_in('old_thumbnail.jpg', thumbnails)
    
    @p.patch_get_resource_path
    def test_does_not_remove_old_thumbnail_for_textfile(self, _patch):
        _patch.return_value = os.path.join(p.resources_path, 'transparenz.rdf')
        open(os.path.join(p.thumbnail_folder, 'old_thumbnail.jpg'), 'a').close()
        thumbnail._create_thumbnail_from_memory(dict(), 'old_thumbnail')
        thumbnails = os.listdir(p.thumbnail_folder)
        nt.assert_equal(len(thumbnails), 1)
        nt.assert_in('old_thumbnail.jpg', thumbnails)

    
    @p.patch_get_resource_path
    def test_returns_None_for_textfile(self, _patch):
        _patch.return_value = os.path.join(p.resources_path, 'transparenz.rdf')
        is_pdf, filename = thumbnail._create_thumbnail_from_memory(dict(), '')
        nt.assert_false(is_pdf)
        nt.assert_is(filename, None)


class TestRemoveThumbnail(p.WithTempFolder):

    @p.patch_get_filename_from_context
    def test_it_removes_thumbnail(self, _patch):
        open(os.path.join(p.thumbnail_folder, 'some_thumbnail.jpg'), 'a').close()
        thumbnails = os.listdir(p.thumbnail_folder)
        nt.assert_equal(len(thumbnails), 1)
        thumbnail.remove_thumbnail(dict())
        thumbnails = os.listdir(p.thumbnail_folder)
        nt.assert_equal(len(thumbnails), 0)


class TestCreateThumbnail(object):

    @p.patch_create_thumbnail_from_memory
    @p.patch_get_filename_from_context
    def test_creates_thumbnail_from_memory(self, patch_gffc, patch_ctfm):
        resource = {
            'url_type': 'upload',
        }
        thumbnail.create_thumbnail(dict(), resource)
        patch_ctfm.assert_called_once_with(resource, 'some_thumbnail.jpg')

    @p.patch_get_filename_from_context
    def test_returns_None_if_type_not_upload(self, patch_gffc):
        resource = {
            'url_type': 'something',
        }
        is_pdf, filename = thumbnail.create_thumbnail(dict(), resource)
        nt.assert_false(is_pdf)
        nt.assert_equal(filename, None)
    

class TestThumbnailPath(p.WithTempFolder):

    def test_from_filename(self):
        tp = thumbnail.ThumbnailPath.from_filename('filename')
        nt.assert_equal(tp.folder, p.thumbnail_folder)
        nt.assert_equal(tp.filename, 'filename')
        nt.assert_equal(tp.extension, '.jpg')
    
    def test_from_filename_with_extension(self):
        tp = thumbnail.ThumbnailPath.from_filename_with_extension('filename.jpg')
        nt.assert_equal(tp.filename, 'filename')
        nt.assert_equal(tp.extension, '.jpg')
    
    def test_from_filename_with_extension_no_extension(self):
        tp = thumbnail.ThumbnailPath.from_filename_with_extension('filename')
        nt.assert_equal(tp.filename, 'filename')
        nt.assert_equal(tp.extension, '')
    
    def test_full_filename(self):
        tp = thumbnail.ThumbnailPath('folder', 'filename', '.jpg')
        nt.assert_equal(tp.full_filename, 'folder/filename.jpg')
    
    @p.patch_random_generator
    def test_from_random_name(self, _patch):
        tp = thumbnail.ThumbnailPath._from_random_name()
        nt.assert_equal(tp.folder, p.thumbnail_folder)
        nt.assert_equal(tp.filename, 'thumbnail_picture_some_random')
        nt.assert_equal(tp.extension, '.jpg')


class TestWriteThumbnailIntoPackage(object):

    def setUp(self):
        p.mock_action_handler.reset_mock()
        p.mock_action_handler.return_value = {'id': 'foo'}
        self.context = {
            'package': Mock(id='foo')
        }

    @p.patch_get_action
    def test_with_filename(self, _patch):
        thumbnail._write_thumbnail_into_package(self.context, 'filename')
        _patch.assert_has_calls([
            call('package_show'), 
            call('package_update')
        ])
        p.mock_action_handler.assert_has_calls([
            call(None, {'id': 'foo'}),
            call(None, {'id': 'foo', 'thumbnail': 'filename'})
        ])
    
    @p.patch_get_action
    def test_without_filename(self, _patch):
        thumbnail._write_thumbnail_into_package(self.context, '')
        _patch.assert_has_calls([
            call('package_show'), 
            call('package_update')
        ])
        p.mock_action_handler.assert_has_calls([
            call(None, {'id': 'foo'}),
            call(None, {'id': 'foo'})
        ])
    

class TestCreateThumbnailIfNoneInPackage(object):

    def setUp(self):
        p.mock_action_handler.reset_mock()
        p.mock_action_handler.return_value = {
            'id': 'foo',
            'resources': [
                {'id': 'id1'},
                {'id': 'id2'},
            ]
        }
        self.context = {
            'package': Mock(id='foo')
        }
    
    @p.patch_get_action
    @p.patch_create_thumbnail
    @p.patch_get_package_dict_from_context
    def test_creates_thumbnail_for_first_resource(self, patch_gpdfc, patch_ct, patch_ga):
        patch_ct.side_effect = [(True, 'filename1'), (True, 'filename2')]
        patch_gpdfc.return_value = {}
        thumbnail.create_thumbnail_if_none_in_package(self.context, ['resource1', 'resource2'])
        patch_ct.assert_called_once_with(self.context, 'resource1')
    
    @p.patch_get_action
    @p.patch_create_thumbnail
    @p.patch_get_package_dict_from_context
    def test_creates_thumbnail_for_first_pdf(self, patch_gpdfc, patch_ct, patch_ga):
        patch_ct.side_effect = [(False, 'filename1'), (True, 'filename2'), (True, 'filename3')]
        patch_gpdfc.return_value = {}
        thumbnail.create_thumbnail_if_none_in_package(self.context, ['resource1', 'resource2', 'resource3'])
        patch_ct.assert_called_with(self.context, 'resource2')
    
    @p.patch_get_action
    @p.patch_create_thumbnail
    @p.patch_get_package_dict_from_context
    def test_does_not_create_thumbnail_if_exists(self, patch_gpdfc, patch_ct, patch_ga):
        patch_gpdfc.return_value = {
            'thumbnail': 'foo.jpg',
        }
        thumbnail.create_thumbnail_if_none_in_package(self.context, ['resource1', 'resource2'])
        patch_ct.assert_not_called()
    
    @p.patch_get_action
    @p.patch_create_thumbnail
    @p.patch_get_package_dict_from_context
    def test_does_not_create_thumbnail_if_no_resources(self, patch_gpdfc, patch_ct, patch_ga):
        patch_gpdfc.return_value = {}
        thumbnail.create_thumbnail_if_none_in_package(self.context, [])
        patch_ct.assert_not_called()
    
    @p.patch_write_thumbnail_into_package
    @p.patch_get_action
    @p.patch_create_thumbnail
    @p.patch_get_package_dict_from_context
    def test_writes_filename_into_package(self, patch_gpdfc, patch_ct, patch_ga, patch_wtip):
        patch_ct.side_effect = [(True, 'filename1'), (True, 'filename2')]
        patch_gpdfc.return_value = {}
        thumbnail.create_thumbnail_if_none_in_package(self.context, ['resource1'])
        patch_wtip.assert_called_once_with(self.context, 'filename1')


class TestHasThumbnail(object):

    def test_true_for_nonempty_string(self):
        nt.assert_true(thumbnail._has_thumbnail({'thumbnail': 'foo'}))
    
    def test_false_for_None(self):
        nt.assert_false(thumbnail._has_thumbnail({'thumbnail': None}))
    
    def test_false_for_empty_string(self):
        nt.assert_false(thumbnail._has_thumbnail({'thumbnail': ''}))

    def test_false_if_not_in_dict(self):
        nt.assert_false(thumbnail._has_thumbnail({}))