describe_template()

Complexity

Conditions

63

Size

Total Lines

170

Duplication

Lines	0
Ratio	0 %

37 Methods

Rating	Name	Duplication	Size	Complexity
A	it_returns_alternate_when_style_provided()	0	3	1
A	with_missing_split()	0	4	2
A	is_none_when_no_file()	0	7	3
A	is_placeholder_when_no_lines()	0	4	2
A	with_no_default_image()	0	2	2
A	it_returns_none_when_no_match()	0	2	1
B	describe_path()	0	17	7
B	describe_sample_path()	0	9	5
A	it_considers_urls_valid_styles()	0	5	1
A	it_returns_the_best_matching_result()	0	4	1
A	it_caches_file_downloads()	0	5	1
A	describe_styles()	0	9	3
A	describe_validate_size()	0	15	3
A	with_no_name()	0	4	2
A	with_cached_valid_link()	0	5	2
B	describe_validate_meta()	0	14	7
A	it_supports_comparison()	0	8	4
A	with_nonalphanumberic_name()	0	4	2
A	with_bad_link()	0	8	3
A	with_various_dimenions()	0	13	2
A	it_returns_default_when_no_style()	0	3	1
A	is_underscore_when_no_lines()	0	4	2
C	describe_validate()	0	16	9
B	describe_validate_link()	0	16	6
A	is_based_on_lines()	0	2	2
A	it_returns_default_when_style_is_none()	0	3	1
A	is_returned_when_file_exists()	0	7	3
A	with_one_failing_validator()	0	5	3
B	describe_default_path()	0	9	5
C	describe_get_path()	0	29	7
A	describe_match()	0	9	3
A	is_empty_when_no_alternate_images()	0	3	1
A	with_no_validators()	0	2	2
A	is_filesnames_of_alternate_images()	0	3	1
A	it_handles_bad_urls()	0	3	1
A	describe_validate_regexes()	0	6	3
A	with_all_passing_validators()	0	5	3

# pylint: disable=unused-variable,expression-not-assigned,misplaced-comparison-constant,singleton-comparison

Bad option value 'misplaced-comparison-constant'

Bad option value 'singleton-comparison'

from unittest.mock import patch, Mock

import pytest
from expecter import expect

The import expecter could not be resolved.

from memegen.domain import Template


def describe_template():

    def it_supports_comparison():
        t1 = Template('abc', "A Thing")
        t2 = Template('def')
        t3 = Template('def', "Do This")

        assert t1 != t2
        assert t2 == t3
        assert t1 < t3

    def describe_get_path():

        @patch('os.path.isfile', Mock(return_value=True))
        def it_returns_default_when_no_style(template):
            expect(template.get_path()) == "abc/default.png"

        @patch('os.path.isfile', Mock(return_value=True))
        def it_returns_alternate_when_style_provided(template):
            expect(template.get_path('Custom')) == "abc/custom.png"

        @patch('os.path.isfile', Mock(return_value=True))
        def it_returns_default_when_style_is_none(template):
            expect(template.get_path(None)) == "abc/default.png"

        @patch('os.path.isfile', Mock(return_value=False))
        def it_considers_urls_valid_styles(template):
            url = "http://example.com"
            path = "/tmp/a9b9f04336ce0181a08e774e01113b31"
            expect(template.get_path(url)) == path

        @patch('os.path.isfile', Mock(return_value=True))
        def it_caches_file_downloads(template):
            url = "http://this/will/be/ignored"
            path = "/tmp/d888710f0697650eb68fc9dcbb976d4c"
            expect(template.get_path(url)) == path

        def it_handles_bad_urls(template):
            url = "http://invalid"
            expect(template.get_path(url)) == None

    def describe_path():

        def is_returned_when_file_exists(template):
            template.root = "my_root"

            with patch('os.path.isfile', Mock(return_value=True)):
                path = template.path

            assert "my_root/abc/default.png" == path

        def is_none_when_no_file(template):
            template.root = "my_root"

            with patch('os.path.isfile', Mock(return_value=False)):
                path = template.path

            assert None is path

    def describe_default_path():

        def is_based_on_lines(template):
            assert "foo/bar" == template.default_path

        def is_underscore_when_no_lines(template):
            template.lines = []

            assert "_" == template.default_path

    def describe_styles():

        @patch('os.listdir', Mock(return_value=[]))
        def is_empty_when_no_alternate_images(template):
            expect(template.styles) == []

        @patch('os.listdir', Mock(return_value=['foo.jpg', 'bar.png']))
        def is_filesnames_of_alternate_images(template):
            expect(template.styles) == ['bar', 'foo']

    def describe_sample_path():

        def is_based_on_lines(template):
            assert "foo/bar" == template.sample_path

        def is_placeholder_when_no_lines(template):
            template.lines = []

            assert "your-text/goes-here" == template.sample_path

    def describe_match():

        def it_returns_none_when_no_match(template):
            expect(template.match("")) == (0, None)

        def it_returns_the_best_matching_result(template):
            template.compile_regexes([r"(\w*)/?(abc)", r"(\w*)/?(def)"])

            expect(template.match("_/def")) == (0.42, "_/def")

    def describe_validate_meta():

        def with_no_name(template):
            template.name = None

            assert False is template.validate_meta()

        def with_no_default_image(template):
            assert False is template.validate_meta()

        def with_nonalphanumberic_name(template):
            template.name = "'ABC' Meme"

            assert False is template.validate_meta()

    def describe_validate_link():

        def with_bad_link(template):
            mock_response = Mock()
            mock_response.status_code = 404

            with patch('requests.get', Mock(return_value=mock_response)):
                template.link = "example.com/fake"

                assert False is template.validate_link()

        @patch('os.path.isfile', Mock(return_value=True))
        def with_cached_valid_link(template):
            template.link = "example.com"

            assert True is template.validate_link()

    def describe_validate_size():

        @pytest.mark.parametrize('dimensions,valid', [
            ((Template.MIN_WIDTH, Template.MIN_HEIGHT), True),
            ((Template.MIN_WIDTH - 1, Template.MIN_HEIGHT), False),
            ((Template.MIN_WIDTH, Template.MIN_HEIGHT - 1), False),
            ((Template.MIN_WIDTH - 1, Template.MIN_HEIGHT - 1), False),
        ])
        @patch('PIL.Image.open')
        def with_various_dimenions(mock_open, template, dimensions, valid):
            mock_img = Mock()
            mock_img.size = dimensions
            mock_open.return_value = mock_img

            assert valid is template.validate_size()

    def describe_validate_regexes():

        def with_missing_split(template):
            template.compile_regexes([".*"])

            assert False is template.validate_regexes()

    def describe_validate():

        def with_no_validators(template):
            assert True is template.validate(validators=[])

        def with_all_passing_validators(template):
            """Verify a template is valid if all validators pass."""
            mock_validators = [lambda: True]

            assert True is template.validate(validators=mock_validators)

        def with_one_failing_validator(template):
            """Verify a template is invalid if any validators fail."""
            mock_validators = [lambda: False]

            assert False is template.validate(validators=mock_validators)