can_be_set_false() - Code Metrics - Inspection of "Split up utilities and decorators" - jacebrowning/yorm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( b4a21c...b1df34 )

by Jace

created 2016-04-12 15:22 UTC

can_be_set_false() A

↳ Parent: describe_modified()

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	4
rs	10
cc	1

# 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, strict=True)
    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_ignores_new_attributes(obj, mapper):
            mapper.create()
            mapper.text = "var4: foo"

            mapper.fetch()
            with expect.raises(AttributeError):
                print(obj.var4)

        def it_infers_types_on_new_attributes_when_not_strict(obj, mapper):
            mapper.strict = False
            mapper.create()
            mapper.text = "var4: foo"

            mapper.fetch()
            expect(obj.var4) == "foo"

            obj.var4 = 42
            mapper.store()

            mapper.fetch()
            expect(obj.var4) == "42"

        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_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()

    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


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, strict=True)
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_ignores_new_attributes(obj, mapper):
103			mapper.create()
104			mapper.text = "var4: foo"
105
106			mapper.fetch()
107			with expect.raises(AttributeError):
108			print(obj.var4)
109
110			def it_infers_types_on_new_attributes_when_not_strict(obj, mapper):
111			mapper.strict = False
112			mapper.create()
113			mapper.text = "var4: foo"
114
115			mapper.fetch()
116			expect(obj.var4) == "foo"
117
118			obj.var4 = 42
119			mapper.store()
120
121			mapper.fetch()
122			expect(obj.var4) == "42"
123
124			def it_raises_an_exception_after_delete(mapper):
125			mapper.delete()
126
127			with expect.raises(exceptions.FileDeletedError):
128			mapper.fetch()
129
130			def describe_store():
131
132			def it_creates_the_file_automatically(mapper_real):
133			mapper_real.store()
134
135			expect(mapper_real.path).exists()
136
137			def describe_modified():
138
139			def is_true_initially(mapper):
140			expect(mapper.modified).is_true()
141
142			def is_true_after_create(mapper):
143			mapper.create()
144
145			expect(mapper.modified).is_true()
146
147			def is_true_after_delete(mapper):
148			mapper.delete()
149
150			expect(mapper.modified).is_true()
151
152			def is_false_after_fetch(mapper):
153			mapper.create()
154			mapper.fetch()
155
156			expect(mapper.modified).is_false()
157
158			def can_be_set_false(mapper):
159			mapper.modified = False
160
161			expect(mapper.modified).is_false()
162
163			def can_be_set_true(mapper):
164			mapper.modified = True
165
166			expect(mapper.modified).is_true()
167
168			def describe_text():
169
170			def can_get_the_file_contents(obj, mapper):
171			obj.var3 = 42
172			mapper.store()
173
174			expect(mapper.text) == "var2: 0\nvar3: 42\n"
175
176			def can_set_the_file_contents(obj, mapper):
177			mapper.create()
178			mapper.text = "var2: 42\n"
179			mapper.fetch()
180
181			expect(obj.var2) == 42
182

jacebrowning / yorm

Push — develop ( b4a21c...b1df34 )

can_be_set_false() A

Complexity

Size

Duplication

1. Missing Dependencies

2. Missing __init__.py files

Duplication Side-by-Side

Filter issues like

2. Missing init.py files