OSMAlchemyModelTests.test_create_way_with_nodes() - Code Metrics - Inspection of "Stabilise ordering of tags." - Natureshadow/OSMAlchemy - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7ab9b4...07f0b5 )

by Dominik

created 2016-08-04 20:50 UTC

OSMAlchemyModelTests.test_create_way_with_nodes() A

↳ Parent: OSMAlchemyModelTests

Complexity

Conditions

Size

Total Lines

Duplication

Lines	21
Ratio	100 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	21
loc	21
rs	9.3142
cc	1

#!/usr/bin/env python
# ~*~ coding: utf-8 ~*~

# Standard unit testing framework
import unittest

# We want to profile test cases
import time

# Helper libraries for different database engines
from testing.mysqld import MysqldFactory
from testing.postgresql import PostgresqlFactory

# Module to be tested
from osmalchemy import OSMAlchemy

# SQLAlchemy for working with model and data
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# Create database engine factories to enable caching
Postgresql = PostgresqlFactory(cache_initialized_db=True)
Mysqld = MysqldFactory(cache_initialized_db=True)

# Dictionary to store profiling information about tests
profile = {}

def tearDownModule():
    """ Global test suite tear down code """

    # Purge caches of database engines
    Postgresql.clear_cache()
    Mysqld.clear_cache()

    # Print profiling info
    print("Database model test times")
    print("=========================")
    print("")
    for suite in profile:
        print("%8.3f s\t%s" % (sum([profile[suite][test] for test in profile[suite]]), suite))
        for test in profile[suite]:
            print("\t%8.3f s\t%s" % (profile[suite][test], test))

class OSMAlchemyModelTests(object):
    """ Incomplete base class for common test routines.

    Subclassed in engine-dependent test classes.
    """

    def setUp(self):
        if not self.__class__.__name__ in profile:
            profile[self.__class__.__name__] = {}
        profile[self.__class__.__name__][self.id().split(".")[-1]] = time.time()

        self.base = declarative_base(bind=self.engine)
        self.osmalchemy = OSMAlchemy(self.base)
        self.base.metadata.create_all()
        self.session = sessionmaker(bind=self.engine)()

    def tearDown(self):
        self.session.close()
        self.engine.dispose()

        profile[self.__class__.__name__][self.id().split(".")[-1]] -= time.time()
        profile[self.__class__.__name__][self.id().split(".")[-1]] *= -1

    def test_create_node(self):
        # Create node
        node = self.osmalchemy.Node()
        node.latitude = 51.0
        node.longitude = 7.0

        # Store node
        self.session.add(node)
        self.session.commit()

        # Query for node and check
        node = self.session.query(self.osmalchemy.Node).filter_by(latitude=51.0).first()
        self.assertEqual(node.latitude, 51.0)
        self.assertEqual(node.longitude, 7.0)
        self.assertEqual(len(node.tags), 0)

    def test_create_node_with_tags(self):
        # Create node and tags
        node = self.osmalchemy.Node(51.0, 7.0)
        node.tags = [self.osmalchemy.Tag("name", "test"),
                     self.osmalchemy.Tag("foo", "bar")]

        # Store everything
        self.session.add(node)
        self.session.commit()

        # Query for node and check
        node = self.session.query(self.osmalchemy.Node).filter_by(latitude=51.0).first()
        self.assertEqual(node.latitude, 51.0)
        self.assertEqual(node.longitude, 7.0)
        self.assertEqual(len(node.tags), 2)
        self.assertEqual((node.tags[0].key, node.tags[0].value), ("foo", "bar"))
        self.assertEqual((node.tags[1].key, node.tags[1].value), ("name", "test"))

    def test_create_way_with_nodes(self):

        # Create way and nodes
        way = self.osmalchemy.Way()
        way.nodes = [self.osmalchemy.Node(51.0, 7.0),
                     self.osmalchemy.Node(51.1, 7.1),
                     self.osmalchemy.Node(51.2, 7.2),
                     self.osmalchemy.Node(51.3, 7.3),
                     self.osmalchemy.Node(51.4, 7.4)]

        # Store everything
        self.session.add(way)
        self.session.commit()

        # Query for way and check
        way = self.session.query(self.osmalchemy.Way).first()
        self.assertEqual(len(way.nodes), 5)
        self.assertEqual((way.nodes[0].latitude, way.nodes[0].longitude), (51.0, 7.0))
        self.assertEqual((way.nodes[1].latitude, way.nodes[1].longitude), (51.1, 7.1))
        self.assertEqual((way.nodes[2].latitude, way.nodes[2].longitude), (51.2, 7.2))
        self.assertEqual((way.nodes[3].latitude, way.nodes[3].longitude), (51.3, 7.3))
        self.assertEqual((way.nodes[4].latitude, way.nodes[4].longitude), (51.4, 7.4))

    def test_create_way_with_nodes_and_tags(self):
        # Create way and nodes
        way = self.osmalchemy.Way()
        way.nodes = [self.osmalchemy.Node(51.0, 7.0),
                     self.osmalchemy.Node(51.1, 7.1),
                     self.osmalchemy.Node(51.2, 7.2),
                     self.osmalchemy.Node(51.3, 7.3),
                     self.osmalchemy.Node(51.4, 7.4)]
        way.tags = [self.osmalchemy.Tag("name", "Testway"),
                    self.osmalchemy.Tag("foo", "bar")]

        # Store everything
        self.session.add(way)
        self.session.commit()

        # Query for way and check
        way = self.session.query(self.osmalchemy.Way).first()
        self.assertEqual(len(way.nodes), 5)
        self.assertEqual((way.nodes[0].latitude, way.nodes[0].longitude), (51.0, 7.0))
        self.assertEqual((way.nodes[1].latitude, way.nodes[1].longitude), (51.1, 7.1))
        self.assertEqual((way.nodes[2].latitude, way.nodes[2].longitude), (51.2, 7.2))
        self.assertEqual((way.nodes[3].latitude, way.nodes[3].longitude), (51.3, 7.3))
        self.assertEqual((way.nodes[4].latitude, way.nodes[4].longitude), (51.4, 7.4))
        self.assertEqual(len(way.tags), 2)
        self.assertEqual((way.tags[0].key, way.tags[0].value), ("foo", "bar"))
        self.assertEqual((way.tags[1].key, way.tags[1].value), ("name", "Testway"))

    def test_create_way_with_nodes_and_tags_and_tags_on_node(self):
        # Create way and nodes
        way = self.osmalchemy.Way()
        way.nodes = [self.osmalchemy.Node(51.0, 7.0),
                     self.osmalchemy.Node(51.1, 7.1),
                     self.osmalchemy.Node(51.2, 7.2),
                     self.osmalchemy.Node(51.3, 7.3),
                     self.osmalchemy.Node(51.4, 7.4)]
        way.tags = [self.osmalchemy.Tag("name", "Testway"),
                    self.osmalchemy.Tag("foo", "bar")]
        way.nodes[2].tags = [self.osmalchemy.Tag("name", "Testampel"),
                             self.osmalchemy.Tag("foo", "bar")]

        # Store everything
        self.session.add(way)
        self.session.commit()

        # Query for way and check
        way = self.session.query(self.osmalchemy.Way).first()
        self.assertEqual(len(way.nodes), 5)
        self.assertEqual((way.nodes[0].latitude, way.nodes[0].longitude), (51.0, 7.0))
        self.assertEqual((way.nodes[1].latitude, way.nodes[1].longitude), (51.1, 7.1))
        self.assertEqual((way.nodes[2].latitude, way.nodes[2].longitude), (51.2, 7.2))
        self.assertEqual((way.nodes[3].latitude, way.nodes[3].longitude), (51.3, 7.3))
        self.assertEqual((way.nodes[4].latitude, way.nodes[4].longitude), (51.4, 7.4))
        self.assertEqual(len(way.tags), 2)
        self.assertEqual((way.tags[0].key, way.tags[0].value), ("foo", "bar"))
        self.assertEqual((way.tags[1].key, way.tags[1].value), ("name", "Testway"))
        self.assertEqual(len(way.nodes[2].tags), 2)
        self.assertEqual((way.nodes[2].tags[0].key, way.nodes[2].tags[0].value), ("foo", "bar"))
        self.assertEqual((way.nodes[2].tags[1].key, way.nodes[2].tags[1].value), ("name", "Testampel"))
        self.assertIsNot(way.tags[0], way.nodes[2].tags[0])
        self.assertIsNot(way.tags[1], way.nodes[2].tags[1])

    def test_create_relation_with_nodes(self):

        # Create way and add nodes
        relation = self.osmalchemy.Relation()
        relation.members = [self.osmalchemy.Node(51.0, 7.0),
                            self.osmalchemy.Node(51.1, 7.1),
                            self.osmalchemy.Node(51.2, 7.2),
                            self.osmalchemy.Node(51.3, 7.3),
                            self.osmalchemy.Node(51.4, 7.4)]

        # Store everything
        self.session.add(relation)
        self.session.commit()

        # Query for way and check
        relation = self.session.query(self.osmalchemy.Relation).first()
        self.assertEqual((relation.members[0].latitude, relation.members[0].longitude),
                         (51.0, 7.0))
        self.assertEqual((relation.members[1].latitude, relation.members[1].longitude),
                         (51.1, 7.1))
        self.assertEqual((relation.members[2].latitude, relation.members[2].longitude),
                         (51.2, 7.2))
        self.assertEqual((relation.members[3].latitude, relation.members[3].longitude),
                         (51.3, 7.3))
        self.assertEqual((relation.members[4].latitude, relation.members[4].longitude),
                         (51.4, 7.4))

    def test_create_relation_with_nodes_and_ways(self):
        # Create way and add nodes and ways
        relation = self.osmalchemy.Relation()
        relation.members = [self.osmalchemy.Node(51.0, 7.0),
                            self.osmalchemy.Way(),
                            self.osmalchemy.Node(51.1, 7.1),
                            self.osmalchemy.Way(),
                            self.osmalchemy.Node(51.2, 7.2),
                            self.osmalchemy.Way(),
                            self.osmalchemy.Node(51.3, 7.3),
                            self.osmalchemy.Way(),
                            self.osmalchemy.Node(51.4, 7.4)]
        relation.members[3].nodes.append(relation.members[8])

        # Store everything
        self.session.add(relation)
        self.session.commit()

        # Query for way and check
        relation = self.session.query(self.osmalchemy.Relation).first()
        self.assertEqual((relation.members[0].latitude, relation.members[0].longitude),
                         (51.0, 7.0))
        self.assertEqual((relation.members[2].latitude, relation.members[2].longitude),
                         (51.1, 7.1))
        self.assertEqual((relation.members[4].latitude, relation.members[4].longitude),
                         (51.2, 7.2))
        self.assertEqual((relation.members[6].latitude, relation.members[6].longitude),
                         (51.3, 7.3))
        self.assertEqual((relation.members[8].latitude, relation.members[8].longitude),
                         (51.4, 7.4))
        self.assertIs(relation.members[3].nodes[0], relation.members[8])

class OSMAlchemyModelTestsSQLite(OSMAlchemyModelTests, unittest.TestCase):
    """ Tests run with SQLite """

    def setUp(self):
        self.engine = create_engine("sqlite:///:memory:", echo=True)
        OSMAlchemyModelTests.setUp(self)

    def tearDown(self):
        OSMAlchemyModelTests.tearDown(self)

class OSMAlchemyModelTestsPostgres(OSMAlchemyModelTests, unittest.TestCase):
    """ Tests run with PostgreSQL """

    def setUp(self):
        self.postgresql = Postgresql()
        self.engine = create_engine(self.postgresql.url(), echo=True)
        OSMAlchemyModelTests.setUp(self)

    def tearDown(self):
        self.postgresql.stop()
        OSMAlchemyModelTests.tearDown(self)

class OSMAlchemyModelTestsMySQL(OSMAlchemyModelTests, unittest.TestCase):
    """ Tests run with MySQL """

    def setUp(self):
        self.mysql = Mysqld()
        self.engine = create_engine(self.mysql.url(), echo=True)
        OSMAlchemyModelTests.setUp(self)

    def tearDown(self):
        self.mysql.stop()
        OSMAlchemyModelTests.tearDown(self)


1		#!/usr/bin/env python
2		# ~~ coding: utf-8 ~~
3
4		# Standard unit testing framework
5		import unittest
6
7		# We want to profile test cases
8		import time
9
10		# Helper libraries for different database engines
11		from testing.mysqld import MysqldFactory
12		from testing.postgresql import PostgresqlFactory
13
14		# Module to be tested
15		from osmalchemy import OSMAlchemy
16
17		# SQLAlchemy for working with model and data
18		from sqlalchemy import create_engine
19		from sqlalchemy.ext.declarative import declarative_base
20		from sqlalchemy.orm import sessionmaker
21
22		# Create database engine factories to enable caching
23		Postgresql = PostgresqlFactory(cache_initialized_db=True)
24		Mysqld = MysqldFactory(cache_initialized_db=True)
25
26		# Dictionary to store profiling information about tests
27		profile = {}
28
29		def tearDownModule():
30		""" Global test suite tear down code """
31
32		# Purge caches of database engines
33		Postgresql.clear_cache()
34		Mysqld.clear_cache()
35
36		# Print profiling info
37		print("Database model test times")
38		print("=========================")
39		print("")
40		for suite in profile:
41		print("%8.3f s\t%s" % (sum([profile[suite][test] for test in profile[suite]]), suite))
42		for test in profile[suite]:
43		print("\t%8.3f s\t%s" % (profile[suite][test], test))
44
45		class OSMAlchemyModelTests(object):
46		""" Incomplete base class for common test routines.
47
48		Subclassed in engine-dependent test classes.
49		"""
50
51		def setUp(self):
52		if not self.__class__.__name__ in profile:
53		profile[self.__class__.__name__] = {}
54		profile[self.__class__.__name__][self.id().split(".")[-1]] = time.time()
55
56		self.base = declarative_base(bind=self.engine)
57		self.osmalchemy = OSMAlchemy(self.base)
58		self.base.metadata.create_all()
59		self.session = sessionmaker(bind=self.engine)()
60
61		def tearDown(self):
62		self.session.close()
63		self.engine.dispose()
64
65		profile[self.__class__.__name__][self.id().split(".")[-1]] -= time.time()
66		profile[self.__class__.__name__][self.id().split(".")[-1]] *= -1
67
68		def test_create_node(self):
69		# Create node
70		node = self.osmalchemy.Node()
71		node.latitude = 51.0
72		node.longitude = 7.0
73
74		# Store node
75		self.session.add(node)
76		self.session.commit()
77
78		# Query for node and check
79		node = self.session.query(self.osmalchemy.Node).filter_by(latitude=51.0).first()
80		self.assertEqual(node.latitude, 51.0)
81		self.assertEqual(node.longitude, 7.0)
82		self.assertEqual(len(node.tags), 0)
83
84		def test_create_node_with_tags(self):
85		# Create node and tags
86		node = self.osmalchemy.Node(51.0, 7.0)
87		node.tags = [self.osmalchemy.Tag("name", "test"),
88		self.osmalchemy.Tag("foo", "bar")]
89
90		# Store everything
91		self.session.add(node)
92		self.session.commit()
93
94		# Query for node and check
95		node = self.session.query(self.osmalchemy.Node).filter_by(latitude=51.0).first()
96		self.assertEqual(node.latitude, 51.0)
97		self.assertEqual(node.longitude, 7.0)
98		self.assertEqual(len(node.tags), 2)
99		self.assertEqual((node.tags[0].key, node.tags[0].value), ("foo", "bar"))
100		self.assertEqual((node.tags[1].key, node.tags[1].value), ("name", "test"))
101
102	View Code Duplication	def test_create_way_with_nodes(self):
		0 ignored issues – show Duplication introduced 2016-08-04 20:53 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
103		# Create way and nodes
104		way = self.osmalchemy.Way()
105		way.nodes = [self.osmalchemy.Node(51.0, 7.0),
106		self.osmalchemy.Node(51.1, 7.1),
107		self.osmalchemy.Node(51.2, 7.2),
108		self.osmalchemy.Node(51.3, 7.3),
109		self.osmalchemy.Node(51.4, 7.4)]
110
111		# Store everything
112		self.session.add(way)
113		self.session.commit()
114
115		# Query for way and check
116		way = self.session.query(self.osmalchemy.Way).first()
117		self.assertEqual(len(way.nodes), 5)
118		self.assertEqual((way.nodes[0].latitude, way.nodes[0].longitude), (51.0, 7.0))
119		self.assertEqual((way.nodes[1].latitude, way.nodes[1].longitude), (51.1, 7.1))
120		self.assertEqual((way.nodes[2].latitude, way.nodes[2].longitude), (51.2, 7.2))
121		self.assertEqual((way.nodes[3].latitude, way.nodes[3].longitude), (51.3, 7.3))
122		self.assertEqual((way.nodes[4].latitude, way.nodes[4].longitude), (51.4, 7.4))
123
124		def test_create_way_with_nodes_and_tags(self):
125		# Create way and nodes
126		way = self.osmalchemy.Way()
127		way.nodes = [self.osmalchemy.Node(51.0, 7.0),
128		self.osmalchemy.Node(51.1, 7.1),
129		self.osmalchemy.Node(51.2, 7.2),
130		self.osmalchemy.Node(51.3, 7.3),
131		self.osmalchemy.Node(51.4, 7.4)]
132		way.tags = [self.osmalchemy.Tag("name", "Testway"),
133		self.osmalchemy.Tag("foo", "bar")]
134
135		# Store everything
136		self.session.add(way)
137		self.session.commit()
138
139		# Query for way and check
140		way = self.session.query(self.osmalchemy.Way).first()
141		self.assertEqual(len(way.nodes), 5)
142		self.assertEqual((way.nodes[0].latitude, way.nodes[0].longitude), (51.0, 7.0))
143		self.assertEqual((way.nodes[1].latitude, way.nodes[1].longitude), (51.1, 7.1))
144		self.assertEqual((way.nodes[2].latitude, way.nodes[2].longitude), (51.2, 7.2))
145		self.assertEqual((way.nodes[3].latitude, way.nodes[3].longitude), (51.3, 7.3))
146		self.assertEqual((way.nodes[4].latitude, way.nodes[4].longitude), (51.4, 7.4))
147		self.assertEqual(len(way.tags), 2)
148		self.assertEqual((way.tags[0].key, way.tags[0].value), ("foo", "bar"))
149		self.assertEqual((way.tags[1].key, way.tags[1].value), ("name", "Testway"))
150
151		def test_create_way_with_nodes_and_tags_and_tags_on_node(self):
152		# Create way and nodes
153		way = self.osmalchemy.Way()
154		way.nodes = [self.osmalchemy.Node(51.0, 7.0),
155		self.osmalchemy.Node(51.1, 7.1),
156		self.osmalchemy.Node(51.2, 7.2),
157		self.osmalchemy.Node(51.3, 7.3),
158		self.osmalchemy.Node(51.4, 7.4)]
159		way.tags = [self.osmalchemy.Tag("name", "Testway"),
160		self.osmalchemy.Tag("foo", "bar")]
161		way.nodes[2].tags = [self.osmalchemy.Tag("name", "Testampel"),
162		self.osmalchemy.Tag("foo", "bar")]
163
164		# Store everything
165		self.session.add(way)
166		self.session.commit()
167
168		# Query for way and check
169		way = self.session.query(self.osmalchemy.Way).first()
170		self.assertEqual(len(way.nodes), 5)
171		self.assertEqual((way.nodes[0].latitude, way.nodes[0].longitude), (51.0, 7.0))
172		self.assertEqual((way.nodes[1].latitude, way.nodes[1].longitude), (51.1, 7.1))
173		self.assertEqual((way.nodes[2].latitude, way.nodes[2].longitude), (51.2, 7.2))
174		self.assertEqual((way.nodes[3].latitude, way.nodes[3].longitude), (51.3, 7.3))
175		self.assertEqual((way.nodes[4].latitude, way.nodes[4].longitude), (51.4, 7.4))
176		self.assertEqual(len(way.tags), 2)
177		self.assertEqual((way.tags[0].key, way.tags[0].value), ("foo", "bar"))
178		self.assertEqual((way.tags[1].key, way.tags[1].value), ("name", "Testway"))
179		self.assertEqual(len(way.nodes[2].tags), 2)
180		self.assertEqual((way.nodes[2].tags[0].key, way.nodes[2].tags[0].value), ("foo", "bar"))
181		self.assertEqual((way.nodes[2].tags[1].key, way.nodes[2].tags[1].value), ("name", "Testampel"))
182		self.assertIsNot(way.tags[0], way.nodes[2].tags[0])
183		self.assertIsNot(way.tags[1], way.nodes[2].tags[1])
184
185	View Code Duplication	def test_create_relation_with_nodes(self):
		0 ignored issues – show Duplication introduced 2016-08-04 20:53 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
186		# Create way and add nodes
187		relation = self.osmalchemy.Relation()
188		relation.members = [self.osmalchemy.Node(51.0, 7.0),
189		self.osmalchemy.Node(51.1, 7.1),
190		self.osmalchemy.Node(51.2, 7.2),
191		self.osmalchemy.Node(51.3, 7.3),
192		self.osmalchemy.Node(51.4, 7.4)]
193
194		# Store everything
195		self.session.add(relation)
196		self.session.commit()
197
198		# Query for way and check
199		relation = self.session.query(self.osmalchemy.Relation).first()
200		self.assertEqual((relation.members[0].latitude, relation.members[0].longitude),
201		(51.0, 7.0))
202		self.assertEqual((relation.members[1].latitude, relation.members[1].longitude),
203		(51.1, 7.1))
204		self.assertEqual((relation.members[2].latitude, relation.members[2].longitude),
205		(51.2, 7.2))
206		self.assertEqual((relation.members[3].latitude, relation.members[3].longitude),
207		(51.3, 7.3))
208		self.assertEqual((relation.members[4].latitude, relation.members[4].longitude),
209		(51.4, 7.4))
210
211		def test_create_relation_with_nodes_and_ways(self):
212		# Create way and add nodes and ways
213		relation = self.osmalchemy.Relation()
214		relation.members = [self.osmalchemy.Node(51.0, 7.0),
215		self.osmalchemy.Way(),
216		self.osmalchemy.Node(51.1, 7.1),
217		self.osmalchemy.Way(),
218		self.osmalchemy.Node(51.2, 7.2),
219		self.osmalchemy.Way(),
220		self.osmalchemy.Node(51.3, 7.3),
221		self.osmalchemy.Way(),
222		self.osmalchemy.Node(51.4, 7.4)]
223		relation.members[3].nodes.append(relation.members[8])
224
225		# Store everything
226		self.session.add(relation)
227		self.session.commit()
228
229		# Query for way and check
230		relation = self.session.query(self.osmalchemy.Relation).first()
231		self.assertEqual((relation.members[0].latitude, relation.members[0].longitude),
232		(51.0, 7.0))
233		self.assertEqual((relation.members[2].latitude, relation.members[2].longitude),
234		(51.1, 7.1))
235		self.assertEqual((relation.members[4].latitude, relation.members[4].longitude),
236		(51.2, 7.2))
237		self.assertEqual((relation.members[6].latitude, relation.members[6].longitude),
238		(51.3, 7.3))
239		self.assertEqual((relation.members[8].latitude, relation.members[8].longitude),
240		(51.4, 7.4))
241		self.assertIs(relation.members[3].nodes[0], relation.members[8])
242
243		class OSMAlchemyModelTestsSQLite(OSMAlchemyModelTests, unittest.TestCase):
244		""" Tests run with SQLite """
245
246		def setUp(self):
247		self.engine = create_engine("sqlite:///:memory:", echo=True)
248		OSMAlchemyModelTests.setUp(self)
249
250		def tearDown(self):
251		OSMAlchemyModelTests.tearDown(self)
252
253		class OSMAlchemyModelTestsPostgres(OSMAlchemyModelTests, unittest.TestCase):
254		""" Tests run with PostgreSQL """
255
256		def setUp(self):
257		self.postgresql = Postgresql()
258		self.engine = create_engine(self.postgresql.url(), echo=True)
259		OSMAlchemyModelTests.setUp(self)
260
261		def tearDown(self):
262		self.postgresql.stop()
263		OSMAlchemyModelTests.tearDown(self)
264
265		class OSMAlchemyModelTestsMySQL(OSMAlchemyModelTests, unittest.TestCase):
266		""" Tests run with MySQL """
267
268		def setUp(self):
269		self.mysql = Mysqld()
270		self.engine = create_engine(self.mysql.url(), echo=True)
271		OSMAlchemyModelTests.setUp(self)
272
273		def tearDown(self):
274		self.mysql.stop()
275		OSMAlchemyModelTests.tearDown(self)
276

Natureshadow / OSMAlchemy

Push — master ( 7ab9b4...07f0b5 )

OSMAlchemyModelTests.test_create_way_with_nodes() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like