BaseAbstractNodeTests.testBasicConstructor() - Code Metrics - Inspection of "Adds support for 'response-language' in request" - ProjetPP/PPP-datamodel-Python - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#51)

by Thomas

created 2016-09-27 17:28 UTC

BaseAbstractNodeTests.testBasicConstructor() A

↳ Parent: BaseAbstractNodeTests

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
c	0
b	0
f	0
dl	0
loc	5
ccs	5
cts	5
cp	1
crap	2
rs	9.4285

import json
import datetime

from ppp_datamodel import AbstractNode, Triple, Resource, Missing
from ppp_datamodel import List, Union, Intersection
from ppp_datamodel import exceptions

from unittest import TestCase

R = Resource
r = lambda x:{'type': 'resource', 'value': x}
M = Missing
m = lambda:{'type': 'missing'}

class BaseAbstractNodeTests(TestCase):
    def testAbstract(self):
        self.assertRaises(TypeError, AbstractNode)

    def testBasicConstructor(self):
        n = Triple(subject=R('s'), predicate=R('p'), object=R('o'))
        self.assertEqual(n.subject, R('s'))
        self.assertEqual(n['subject'], R('s'))
        self.assertRaises(AttributeError, lambda: n.foobar)

    def testSet(self):
        n = Triple(subject=R('s'), predicate=R('p'), object=R('o'))
        with self.assertRaises(TypeError):
            n.predicate = R('test')
        with self.assertRaises(TypeError):
            del n.predicate


    def testEmptyConstructor(self):
        n = Triple()
        self.assertRaises(exceptions.AttributeNotProvided,
            lambda: n.predicate)

    def testInvalidConstrutorAttribute(self):
        self.assertRaises(TypeError, Triple, foo='bar')

    def testToJsonPerfect(self):
        n = Triple(subject=R('s'), predicate=R('p'), object=R('o'))
        self.assertEqual(json.loads(n.as_json()), {'type': 'triple',
            'subject': r('s'), 'predicate': r('p'), 'object': r('o')})

    def testToJsonMissing(self):
        n = Triple(subject=R('s'), predicate=R('p'))
        self.assertEqual(json.loads(n.as_json()), {'type': 'triple',
            'subject': r('s'), 'predicate': r('p')})

    def testToJsonNone(self):
        n = Triple(subject=R('s'), predicate=R('p'), object=Missing())
        self.assertEqual(json.loads(n.as_json()), {'type': 'triple',
            'subject': r('s'), 'predicate': r('p'), 'object': m()})

    def testFromJsonPerfect(self):
        d = {'type': 'triple',
            'subject': r('s'), 'predicate': r('p'), 'object': r('o')}
        self.assertIsInstance(AbstractNode.from_dict(d), Triple)
        self.assertIsInstance(AbstractNode.from_json(json.dumps(d)), Triple)
        self.assertEqual(d, json.loads(AbstractNode.from_dict(d).as_json()))
        self.assertEqual(d, json.loads(AbstractNode.from_json(json.dumps(d)).as_json()))
        self.assertIsInstance(AbstractNode.from_json(json.dumps(d)).subject, Resource)
        self.assertEqual(AbstractNode.from_json(json.dumps(d)).subject.value, 's')

    def testFromJsonMissing(self):
        d = {'type': 'triple',
            'subject': r('s'), 'predicate': r('p')}
        n = AbstractNode.from_dict(d)
        self.assertEqual(d, json.loads(n.as_json()))
        self.assertEqual(n.predicate, r('p'))
        self.assertNotIn('object', n)

    def testFromJsonNone(self):
        d = {'type': 'triple',
             'subject': r('s'), 'predicate': r('p'), 'object': m()}
        n = AbstractNode.from_dict(d)
        self.assertEqual(d, json.loads(n.as_json()))
        self.assertIn('object', n)
        self.assertEqual(n.object, M())

    def testFromJsonTypeNotProvided(self):
        d = {'subject': r('s'), 'predicate': r('p'), 'object': m()}
        self.assertRaises(exceptions.AttributeNotProvided,
                AbstractNode.from_dict, d)

    def testFromJsonTypeInvalid(self):
        d = {'type': 'foobar',
            'subject': r('s'), 'predicate': r('p'), 'object': m()}
        self.assertRaises(exceptions.UnknownNodeType,
                AbstractNode.from_dict, d)

    def testCheckType(self):
        self.assertRaises(TypeError, Triple, {})

    def testEq(self):
        self.assertEqual(Missing(), Missing())
        self.assertEqual(Resource('foo'), Resource('foo'))
        self.assertNotEqual(Missing(), Resource('foo'))
        self.assertEqual(Missing(), {'type': 'missing'})
        self.assertNotEqual(Missing(), {'type': 'missing', 'f': 'b'})
        self.assertEqual(Resource('foo'), {'type': 'resource',
                                           'value': 'foo'})
        self.assertNotEqual(Missing(), '')

    def testList(self):
        r1 = {'type': 'resource', 'value': 'foo'}
        r2 = {'type': 'resource', 'value': 'bar'}
        d = {'type': 'list', 'list': [r1, r2]}
        o = AbstractNode.from_dict(d)
        self.assertEqual(o.list, [Resource('foo'), Resource('bar')])
        self.assertIsInstance(o.list[1], Resource)
        self.assertEqual(o.as_dict(), d)

    def testSerialize(self):
        d = {'type': 'resource', 'value': 'foo', 'value-type': 'bar', 'baz-qux': 'quux'}
        self.assertEqual(AbstractNode.from_dict(d).as_dict(), d)

    def testTraverse(self):
        def pred(tree):
            if isinstance(tree, Resource):
                return Resource('foo')
            elif isinstance(tree, Triple):
                return Triple(tree.subject, Resource('bar'), tree.object)
            elif isinstance(tree, Missing):
                return Resource('m')
            else:
                return tree
        f = Resource('foo')
        b = Resource('bar')
        m = Resource('m')
        self.assertEqual(Resource('baz').traverse(pred), f)
        tree = Triple(Resource('1'), Resource('2'), Missing())
        self.assertEqual(tree.traverse(pred), Triple(f, b, m))
        tree = List([
                    Resource('4'),
                    Resource('5')
                    ])
        self.assertEqual(tree.traverse(pred),
                List([
                    f,
                    f
                    ]))
        tree = Triple(
                Triple(Resource('1'), Resource('2'), Missing()),
                Resource('3'),
                List([
                    Resource('4'),
                    Resource('5')
                    ]))
        self.assertEqual(tree.traverse(pred),
                Triple(
                    Triple(f, b, m),
                    b,
                    List([
                        f,
                        f,
                        ])))
        tree = Union([List([Resource('1')]), List([Resource('2')])])
        self.assertEqual(tree.traverse(pred),
                Union([List([f]), List([f])]))
        tree = Intersection([List([Resource('1')]), List([Resource('2')])])
        self.assertEqual(tree.traverse(pred),
                Intersection([List([f]), List([f])]))

    def testTraverseContract(self):
        f = Resource('foo')
        def pred(tree):
            if isinstance(tree, List):
                return Resource('foo')
            elif isinstance(tree, Intersection):
                self.assertEqual(tree, Intersection([f, f]))
                return tree
            elif isinstance(tree, Resource):
                return tree
            else:
                raise AssertionError(tree)
        tree = Intersection([List([Resource('1')]), List([Resource('2')])])
        self.assertEqual(tree.traverse(pred),
                Intersection([f, f]))

    def testTripleIntersection(self):
        t = Intersection([
            Triple(
                Resource('a'),
                Resource('b'),
                Missing()),
            Triple(
                Resource('c'),
                Resource('d'),
                Missing())])
        AbstractNode.from_dict(t.as_dict())


1	1	import json
2	1	import datetime
3
4	1	from ppp_datamodel import AbstractNode, Triple, Resource, Missing
5	1	from ppp_datamodel import List, Union, Intersection
6	1	from ppp_datamodel import exceptions
7
8	1	from unittest import TestCase
9
10	1	R = Resource
11	1	r = lambda x:{'type': 'resource', 'value': x}
12	1	M = Missing
13	1	m = lambda:{'type': 'missing'}
14
15	1	class BaseAbstractNodeTests(TestCase):
16	1	def testAbstract(self):
17	1	self.assertRaises(TypeError, AbstractNode)
18
19	1	def testBasicConstructor(self):
20	1	n = Triple(subject=R('s'), predicate=R('p'), object=R('o'))
21	1	self.assertEqual(n.subject, R('s'))
22	1	self.assertEqual(n['subject'], R('s'))
23	1	self.assertRaises(AttributeError, lambda: n.foobar)
24
25	1	def testSet(self):
26	1	n = Triple(subject=R('s'), predicate=R('p'), object=R('o'))
27	1	with self.assertRaises(TypeError):
28	1	n.predicate = R('test')
29	1	with self.assertRaises(TypeError):
30	1	del n.predicate
31
32
33	1	def testEmptyConstructor(self):
34	1	n = Triple()
35	1	self.assertRaises(exceptions.AttributeNotProvided,
36		lambda: n.predicate)
37
38	1	def testInvalidConstrutorAttribute(self):
39	1	self.assertRaises(TypeError, Triple, foo='bar')
40
41	1	def testToJsonPerfect(self):
42	1	n = Triple(subject=R('s'), predicate=R('p'), object=R('o'))
43	1	self.assertEqual(json.loads(n.as_json()), {'type': 'triple',
44		'subject': r('s'), 'predicate': r('p'), 'object': r('o')})
45
46	1	def testToJsonMissing(self):
47	1	n = Triple(subject=R('s'), predicate=R('p'))
48	1	self.assertEqual(json.loads(n.as_json()), {'type': 'triple',
49		'subject': r('s'), 'predicate': r('p')})
50
51	1	def testToJsonNone(self):
52	1	n = Triple(subject=R('s'), predicate=R('p'), object=Missing())
53	1	self.assertEqual(json.loads(n.as_json()), {'type': 'triple',
54		'subject': r('s'), 'predicate': r('p'), 'object': m()})
55
56	1	def testFromJsonPerfect(self):
57	1	d = {'type': 'triple',
58		'subject': r('s'), 'predicate': r('p'), 'object': r('o')}
59	1	self.assertIsInstance(AbstractNode.from_dict(d), Triple)
60	1	self.assertIsInstance(AbstractNode.from_json(json.dumps(d)), Triple)
61	1	self.assertEqual(d, json.loads(AbstractNode.from_dict(d).as_json()))
62	1	self.assertEqual(d, json.loads(AbstractNode.from_json(json.dumps(d)).as_json()))
63	1	self.assertIsInstance(AbstractNode.from_json(json.dumps(d)).subject, Resource)
64	1	self.assertEqual(AbstractNode.from_json(json.dumps(d)).subject.value, 's')
65
66	1	def testFromJsonMissing(self):
67	1	d = {'type': 'triple',
68		'subject': r('s'), 'predicate': r('p')}
69	1	n = AbstractNode.from_dict(d)
70	1	self.assertEqual(d, json.loads(n.as_json()))
71	1	self.assertEqual(n.predicate, r('p'))
72	1	self.assertNotIn('object', n)
73
74	1	def testFromJsonNone(self):
75	1	d = {'type': 'triple',
76		'subject': r('s'), 'predicate': r('p'), 'object': m()}
77	1	n = AbstractNode.from_dict(d)
78	1	self.assertEqual(d, json.loads(n.as_json()))
79	1	self.assertIn('object', n)
80	1	self.assertEqual(n.object, M())
81
82	1	def testFromJsonTypeNotProvided(self):
83	1	d = {'subject': r('s'), 'predicate': r('p'), 'object': m()}
84	1	self.assertRaises(exceptions.AttributeNotProvided,
85		AbstractNode.from_dict, d)
86
87	1	def testFromJsonTypeInvalid(self):
88	1	d = {'type': 'foobar',
89		'subject': r('s'), 'predicate': r('p'), 'object': m()}
90	1	self.assertRaises(exceptions.UnknownNodeType,
91		AbstractNode.from_dict, d)
92
93	1	def testCheckType(self):
94	1	self.assertRaises(TypeError, Triple, {})
95
96	1	def testEq(self):
97	1	self.assertEqual(Missing(), Missing())
98	1	self.assertEqual(Resource('foo'), Resource('foo'))
99	1	self.assertNotEqual(Missing(), Resource('foo'))
100	1	self.assertEqual(Missing(), {'type': 'missing'})
101	1	self.assertNotEqual(Missing(), {'type': 'missing', 'f': 'b'})
102	1	self.assertEqual(Resource('foo'), {'type': 'resource',
103		'value': 'foo'})
104	1	self.assertNotEqual(Missing(), '')
105
106	1	def testList(self):
107	1	r1 = {'type': 'resource', 'value': 'foo'}
108	1	r2 = {'type': 'resource', 'value': 'bar'}
109	1	d = {'type': 'list', 'list': [r1, r2]}
110	1	o = AbstractNode.from_dict(d)
111	1	self.assertEqual(o.list, [Resource('foo'), Resource('bar')])
112	1	self.assertIsInstance(o.list[1], Resource)
113	1	self.assertEqual(o.as_dict(), d)
114
115	1	def testSerialize(self):
116	1	d = {'type': 'resource', 'value': 'foo', 'value-type': 'bar', 'baz-qux': 'quux'}
117	1	self.assertEqual(AbstractNode.from_dict(d).as_dict(), d)
118
119	1	def testTraverse(self):
120	1	def pred(tree):
121	1	if isinstance(tree, Resource):
122	1	return Resource('foo')
123	1	elif isinstance(tree, Triple):
124	1	return Triple(tree.subject, Resource('bar'), tree.object)
125	1	elif isinstance(tree, Missing):
126	1	return Resource('m')
127		else:
128	1	return tree
129	1	f = Resource('foo')
130	1	b = Resource('bar')
131	1	m = Resource('m')
132	1	self.assertEqual(Resource('baz').traverse(pred), f)
133	1	tree = Triple(Resource('1'), Resource('2'), Missing())
134	1	self.assertEqual(tree.traverse(pred), Triple(f, b, m))
135	1	tree = List([
136		Resource('4'),
137		Resource('5')
138		])
139	1	self.assertEqual(tree.traverse(pred),
140		List([
141		f,
142		f
143		]))
144	1	tree = Triple(
145		Triple(Resource('1'), Resource('2'), Missing()),
146		Resource('3'),
147		List([
148		Resource('4'),
149		Resource('5')
150		]))
151	1	self.assertEqual(tree.traverse(pred),
152		Triple(
153		Triple(f, b, m),
154		b,
155		List([
156		f,
157		f,
158		])))
159	1	tree = Union([List([Resource('1')]), List([Resource('2')])])
160	1	self.assertEqual(tree.traverse(pred),
161		Union([List([f]), List([f])]))
162	1	tree = Intersection([List([Resource('1')]), List([Resource('2')])])
163	1	self.assertEqual(tree.traverse(pred),
164		Intersection([List([f]), List([f])]))
165
166	1	def testTraverseContract(self):
167	1	f = Resource('foo')
168	1	def pred(tree):
169	1	if isinstance(tree, List):
170	1	return Resource('foo')
171	1	elif isinstance(tree, Intersection):
172	1	self.assertEqual(tree, Intersection([f, f]))
173	1	return tree
174	1	elif isinstance(tree, Resource):
175	1	return tree
176		else:
177		raise AssertionError(tree)
178	1	tree = Intersection([List([Resource('1')]), List([Resource('2')])])
179	1	self.assertEqual(tree.traverse(pred),
180		Intersection([f, f]))
181
182	1	def testTripleIntersection(self):
183	1	t = Intersection([
184		Triple(
185		Resource('a'),
186		Resource('b'),
187		Missing()),
188		Triple(
189		Resource('c'),
190		Resource('d'),
191		Missing())])
192		AbstractNode.from_dict(t.as_dict())
193

ProjetPP / PPP-datamodel-Python

Pull Request — master (#51)

BaseAbstractNodeTests.testBasicConstructor() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like