yorm.test.can_get_the_file_contents() - Code Metrics - Inspection of "Condensed method patching to the same module" - jacebrowning/yorm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( e4f288...dec8f0 )

by Jace

created 2016-02-22 02:45 UTC

yorm.test.can_get_the_file_contents() A

↳ Parent: yorm.test.describe_text()

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	5
rs	9.4285

# pylint: disable=missing-docstring,redefined-outer-name,unused-variable,expression-not-assigned

import pytest
from expecter import expect
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3

import yorm
from yorm import exceptions
from yorm.mapper import Mapper
from yorm.types import Integer


class MyObject:
    var1 = 1


@pytest.fixture
def obj():
    return MyObject()


@pytest.fixture
def attrs():
    return {'var2': Integer, 'var3': Integer}


@pytest.yield_fixture(params=("real", "fake"))
def mapper(tmpdir, obj, attrs, request):
    path = request.param + "/path/to/file"
    backup = yorm.settings.fake
    if "fake" in path:
        yorm.settings.fake = True
    elif "real" in path:
        tmpdir.chdir()
    yield Mapper(obj, path, attrs)
    yorm.settings.fake = backup


@pytest.fixture
def mapper_real(tmpdir, obj, attrs):
    tmpdir.chdir()
    return Mapper(obj, "real/path/to/file", attrs)


@pytest.yield_fixture
def mapper_fake(obj, attrs):
    backup = yorm.settings.fake
    yorm.settings.fake = True
    yield Mapper(obj, "fake/path/to/file", attrs)
    yorm.settings.fake = backup


def describe_mapper():

    def describe_create():

        def it_creates_the_file(mapper_real):
            mapper_real.create()

            expect(mapper_real.path).exists()
            expect(mapper_real.exists).is_true()
            expect(mapper_real.deleted).is_false()

        def it_pretends_when_fake(mapper_fake):
            mapper_fake.create()

            expect(mapper_fake.path).missing()
            expect(mapper_fake.exists).is_true()
            expect(mapper_fake.deleted).is_false()

        def it_can_be_called_twice(mapper_real):
            mapper_real.create()
            mapper_real.create()  # should be ignored

            expect(mapper_real.path).exists()

    def describe_delete():

        def it_deletes_the_file(mapper):
            mapper.create()
            mapper.delete()

            expect(mapper.path).missing()
            expect(mapper.exists).is_false()
            expect(mapper.deleted).is_true()

        def it_can_be_called_twice(mapper):
            mapper.delete()
            mapper.delete()  # should be ignored

            expect(mapper.path).missing()

    def describe_fetch():

        def it_adds_missing_attributes(obj, mapper):
            mapper.create()
            mapper.fetch()

            expect(obj.var1) == 1
            expect(obj.var2) == 0
            expect(obj.var3) == 0

        def it_raises_an_exception_after_delete(mapper):
            mapper.delete()

            with expect.raises(exceptions.FileDeletedError):
                mapper.fetch()

    def describe_store():

        def it_creates_the_file_automatically(mapper_real):
            mapper_real.store()

            expect(mapper_real.path).exists()

    def describe_text():

        def can_get_the_file_contents(obj, mapper):
            obj.var3 = 42
            mapper.store()

            expect(mapper.text) == "var2: 0\nvar3: 42\n"

        def can_set_the_file_contents(obj, mapper):
            mapper.create()
            mapper.text = "var2: 42\n"
            mapper.fetch()

            expect(obj.var2) == 42

    def describe_modified():

        def is_true_initially(mapper):
            expect(mapper.modified).is_true()

        def is_true_after_create(mapper):
            mapper.create()

            expect(mapper.modified).is_true()

        def is_true_after_delete(mapper):
            mapper.delete()

            expect(mapper.modified).is_true()

        def is_false_after_fetch(mapper):
            mapper.create()
            mapper.fetch()

            expect(mapper.modified).is_false()

        def can_be_set_false(mapper):
            mapper.modified = False

            expect(mapper.modified).is_false()

        def can_be_set_true(mapper):
            mapper.modified = True

            expect(mapper.modified).is_true()


1			# pylint: disable=missing-docstring,redefined-outer-name,unused-variable,expression-not-assigned
2
3			import pytest
4			from expecter import expect
			0 ignored issues – show Configuration introduced 2016-02-22 01:35 UTC by Report Bug Copy Issue Report The import `expecter` could not be resolved. This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
5
6			import yorm
7			from yorm import exceptions
8			from yorm.mapper import Mapper
9			from yorm.types import Integer
10
11
12			class MyObject:
13			var1 = 1
14
15
16			@pytest.fixture
17			def obj():
18			return MyObject()
19
20
21			@pytest.fixture
22			def attrs():
23			return {'var2': Integer, 'var3': Integer}
24
25
26			@pytest.yield_fixture(params=("real", "fake"))
27			def mapper(tmpdir, obj, attrs, request):
28			path = request.param + "/path/to/file"
29			backup = yorm.settings.fake
30			if "fake" in path:
31			yorm.settings.fake = True
32			elif "real" in path:
33			tmpdir.chdir()
34			yield Mapper(obj, path, attrs)
35			yorm.settings.fake = backup
36
37
38			@pytest.fixture
39			def mapper_real(tmpdir, obj, attrs):
40			tmpdir.chdir()
41			return Mapper(obj, "real/path/to/file", attrs)
42
43
44			@pytest.yield_fixture
45			def mapper_fake(obj, attrs):
46			backup = yorm.settings.fake
47			yorm.settings.fake = True
48			yield Mapper(obj, "fake/path/to/file", attrs)
49			yorm.settings.fake = backup
50
51
52			def describe_mapper():
53
54			def describe_create():
55
56			def it_creates_the_file(mapper_real):
57			mapper_real.create()
58
59			expect(mapper_real.path).exists()
60			expect(mapper_real.exists).is_true()
61			expect(mapper_real.deleted).is_false()
62
63			def it_pretends_when_fake(mapper_fake):
64			mapper_fake.create()
65
66			expect(mapper_fake.path).missing()
67			expect(mapper_fake.exists).is_true()
68			expect(mapper_fake.deleted).is_false()
69
70			def it_can_be_called_twice(mapper_real):
71			mapper_real.create()
72			mapper_real.create() # should be ignored
73
74			expect(mapper_real.path).exists()
75
76			def describe_delete():
77
78			def it_deletes_the_file(mapper):
79			mapper.create()
80			mapper.delete()
81
82			expect(mapper.path).missing()
83			expect(mapper.exists).is_false()
84			expect(mapper.deleted).is_true()
85
86			def it_can_be_called_twice(mapper):
87			mapper.delete()
88			mapper.delete() # should be ignored
89
90			expect(mapper.path).missing()
91
92			def describe_fetch():
93
94			def it_adds_missing_attributes(obj, mapper):
95			mapper.create()
96			mapper.fetch()
97
98			expect(obj.var1) == 1
99			expect(obj.var2) == 0
100			expect(obj.var3) == 0
101
102			def it_raises_an_exception_after_delete(mapper):
103			mapper.delete()
104
105			with expect.raises(exceptions.FileDeletedError):
106			mapper.fetch()
107
108			def describe_store():
109
110			def it_creates_the_file_automatically(mapper_real):
111			mapper_real.store()
112
113			expect(mapper_real.path).exists()
114
115			def describe_text():
116
117			def can_get_the_file_contents(obj, mapper):
118			obj.var3 = 42
119			mapper.store()
120
121			expect(mapper.text) == "var2: 0\nvar3: 42\n"
122
123			def can_set_the_file_contents(obj, mapper):
124			mapper.create()
125			mapper.text = "var2: 42\n"
126			mapper.fetch()
127
128			expect(obj.var2) == 42
129
130			def describe_modified():
131
132			def is_true_initially(mapper):
133			expect(mapper.modified).is_true()
134
135			def is_true_after_create(mapper):
136			mapper.create()
137
138			expect(mapper.modified).is_true()
139
140			def is_true_after_delete(mapper):
141			mapper.delete()
142
143			expect(mapper.modified).is_true()
144
145			def is_false_after_fetch(mapper):
146			mapper.create()
147			mapper.fetch()
148
149			expect(mapper.modified).is_false()
150
151			def can_be_set_false(mapper):
152			mapper.modified = False
153
154			expect(mapper.modified).is_false()
155
156			def can_be_set_true(mapper):
157			mapper.modified = True
158
159			expect(mapper.modified).is_true()
160

jacebrowning / yorm

Push — develop ( e4f288...dec8f0 )

yorm.test.can_get_the_file_contents() A

Complexity

Size

Duplication

1. Missing Dependencies

2. Missing __init__.py files

Duplication Side-by-Side

Filter issues like

2. Missing init.py files