describe_modified() - Code Metrics - Inspection of "Merge pull request #139 from jacebrowning/release/..." - jacebrowning/yorm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 7d38f7...827c8b )

by Jace

created 2017-01-24 21:20 UTC

describe_modified() C

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	32
rs	5.5
cc	7

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

import pytest
from expecter import expect

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, auto_track=False)
    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_load():

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

            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.load()
            with expect.raises(AttributeError):
                print(obj.var4)

        def it_infers_types_on_new_attributes_with_auto_track(obj, mapper):
            mapper.auto_track = True
            mapper.create()
            mapper.text = "var4: foo"

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

            obj.var4 = 42
            mapper.save()

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

        def it_raises_an_exception_after_delete(mapper):
            mapper.delete()

            with expect.raises(exceptions.DeletedFileError):
                mapper.load()

    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_load(mapper):
            mapper.create()
            mapper.load()

            expect(mapper.modified).is_false()

        def can_be_set_false(mapper):
            mapper.create()
            mapper.modified = False

            expect(mapper.modified).is_false()

        def can_be_set_true(mapper):
            mapper.create()
            mapper.modified = True

            expect(mapper.modified).is_true()

    def describe_text():

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

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

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

            expect(obj.var2) == 42

    def describe_data():

        def can_get_the_file_values(obj, mapper):
            mapper.create()
            obj.var3 = 42
            mapper.save()

            expect(mapper.data) == {'var2': 0, 'var3': 42}

        def can_set_the_file_values(obj, mapper):
            mapper.create()
            mapper.data = {'var2': 42}
            mapper.load()

            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
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, auto_track=False)
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_load():
93
94			def it_adds_missing_attributes(obj, mapper):
95			mapper.create()
96			mapper.load()
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.load()
107			with expect.raises(AttributeError):
108			print(obj.var4)
109
110			def it_infers_types_on_new_attributes_with_auto_track(obj, mapper):
111			mapper.auto_track = True
112			mapper.create()
113			mapper.text = "var4: foo"
114
115			mapper.load()
116			expect(obj.var4) == "foo"
117
118			obj.var4 = 42
119			mapper.save()
120
121			mapper.load()
122			expect(obj.var4) == "42"
123
124			def it_raises_an_exception_after_delete(mapper):
125			mapper.delete()
126
127			with expect.raises(exceptions.DeletedFileError):
128			mapper.load()
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_load(mapper):
146			mapper.create()
147			mapper.load()
148
149			expect(mapper.modified).is_false()
150
151			def can_be_set_false(mapper):
152			mapper.create()
153			mapper.modified = False
154
155			expect(mapper.modified).is_false()
156
157			def can_be_set_true(mapper):
158			mapper.create()
159			mapper.modified = True
160
161			expect(mapper.modified).is_true()
162
163			def describe_text():
164
165			def can_get_the_file_contents(obj, mapper):
166			mapper.create()
167			obj.var3 = 42
168			mapper.save()
169
170			expect(mapper.text) == "var2: 0\nvar3: 42\n"
171
172			def can_set_the_file_contents(obj, mapper):
173			mapper.create()
174			mapper.text = "var2: 42\n"
175			mapper.load()
176
177			expect(obj.var2) == 42
178
179			def describe_data():
180
181			def can_get_the_file_values(obj, mapper):
182			mapper.create()
183			obj.var3 = 42
184			mapper.save()
185
186			expect(mapper.data) == {'var2': 0, 'var3': 42}
187
188			def can_set_the_file_values(obj, mapper):
189			mapper.create()
190			mapper.data = {'var2': 42}
191			mapper.load()
192
193			expect(obj.var2) == 42
194

jacebrowning / yorm

Push — develop ( 7d38f7...827c8b )

describe_modified() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like