source: josm/trunk/test/functional/org/openstreetmap/josm/io/OsmServerBackreferenceReaderTest.java@ 1814

Last change on this file since 1814 was 1814, checked in by Gubaer, 15 years ago

removed dependencies to Main.ds, removed Main.ds
removed AddVisitor, NameVisitor, DeleteVisitor - unnecessary double dispatching for these simple cases
File size: 19.3 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.io;
3
4import static org.junit.Assert.assertEquals;
5import static org.junit.Assert.assertNotNull;
6import static org.junit.Assert.fail;
7
8import java.io.File;
9import java.io.FileInputStream;
10import java.io.FileWriter;
11import java.io.IOException;
12import java.io.PrintWriter;
13import java.text.MessageFormat;
14import java.util.ArrayList;
15import java.util.HashSet;
16import java.util.Properties;
17import java.util.Set;
18import java.util.logging.Level;
19import java.util.logging.Logger;
20
21import org.junit.Before;
22import org.junit.BeforeClass;
23import org.junit.Test;
24import org.openstreetmap.josm.Main;
25import org.openstreetmap.josm.data.coor.LatLon;
26import org.openstreetmap.josm.data.osm.DataSet;
27import org.openstreetmap.josm.data.osm.Node;
28import org.openstreetmap.josm.data.osm.OsmPrimitive;
29import org.openstreetmap.josm.data.osm.Relation;
30import org.openstreetmap.josm.data.osm.RelationMember;
31import org.openstreetmap.josm.data.osm.Way;
32import org.openstreetmap.josm.data.projection.Mercator;
33import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
34import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor;
35import org.xml.sax.SAXException;
36
37public class OsmServerBackreferenceReaderTest {
38 static private final Logger logger = Logger.getLogger(OsmServerBackreferenceReader.class.getName());
39
40 protected static Node lookupNode(DataSet ds, int i) {
41 for (Node n: ds.nodes) {
42 if (("node-" + i).equals(n.get("name"))) return n;
43 }
44 return null;
45 }
46
47
48 protected static Way lookupWay(DataSet ds, int i) {
49 for (Way w: ds.ways) {
50 if (("way-" + i).equals(w.get("name"))) return w;
51 }
52 return null;
53 }
54
55 protected static Relation lookupRelation(DataSet ds, int i) {
56 for (Relation r: ds.relations) {
57 if (("relation-" + i).equals(r.get("name"))) return r;
58 }
59 return null;
60 }
61
62 protected static void populateTestDataSetWithNodes(DataSet ds) {
63 for (int i=0;i<100;i++) {
64 Node n = new Node(0);
65 n.setCoor(new LatLon(-36.6,47.6));
66 n.put("name", "node-"+i);
67 n.incomplete = false;
68 ds.addPrimitive(n);
69 }
70 }
71
72 protected static void populateTestDataSetWithWays(DataSet ds) {
73 for (int i=0;i<20;i++) {
74 Way w = new Way(0);
75 w.incomplete = false;
76 for (int j = 0; j < 10;j++) {
77 w.nodes.add(lookupNode(ds, i+j));
78 }
79 w.put("name", "way-"+i);
80 ds.addPrimitive(w);
81 }
82 }
83
84 protected static void populateTestDataSetWithRelations(DataSet ds) {
85 for (int i=0;i<10;i++) {
86 Relation r = new Relation(0);
87 r.incomplete = false;
88 r.put("name", "relation-" +i);
89 for (int j =0; j < 10; j++) {
90 RelationMember member = new RelationMember();
91 member.role = "node-" + j;
92 member.member = lookupNode(ds, i + j);
93 }
94 for (int j =0; j < 5; j++) {
95 RelationMember member = new RelationMember();
96 member.role = "way-" + j;
97 member.member = lookupWay(ds, i + j);
98 r.members.add(member);
99 }
100 if (i > 5) {
101 for (int j =0; j < 3; j++) {
102 RelationMember member = new RelationMember();
103 member.role = "relation-" + j;
104 member.member = lookupRelation(ds, j);
105 logger.info(MessageFormat.format("adding relation {0} to relation {1}", j, i));
106 r.members.add(member);
107 }
108 }
109 ds.relations.add(r);
110 }
111 }
112
113
114 protected static DataSet buildTestDataSet() {
115 DataSet ds = new DataSet();
116 ds.version = "0.6";
117
118 populateTestDataSetWithNodes(ds);
119 populateTestDataSetWithWays(ds);
120 populateTestDataSetWithRelations(ds);
121 return ds;
122 }
123
124 /**
125 * creates the dataset on the server.
126 *
127 * @param ds the data set
128 * @throws OsmTransferException
129 */
130 static public void createDataSetOnServer(DataSet ds) throws OsmTransferException {
131 logger.info("creating data set on the server ...");
132 ArrayList<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
133 primitives.addAll(ds.nodes);
134 primitives.addAll(ds.ways);
135 primitives.addAll(ds.relations);
136 OsmServerWriter writer = new OsmServerWriter();
137 writer.uploadOsm("0.6", primitives, NullProgressMonitor.INSTANCE);
138 }
139
140 static Properties testProperties;
141 static DataSet testDataSet;
142
143 @BeforeClass
144 public static void init() throws OsmTransferException, InterruptedException{
145 logger.info("initializing ...");
146 testProperties = new Properties();
147
148 // load properties
149 //
150 try {
151 testProperties.load(MultiFetchServerObjectReaderTest.class.getResourceAsStream("/test-functional-env.properties"));
152 } catch(Exception e){
153 logger.log(Level.SEVERE, MessageFormat.format("failed to load property file ''{0}''", "test-functional-env.properties"));
154 fail(MessageFormat.format("failed to load property file ''{0}''", "test-functional-env.properties"));
155 }
156
157 // check josm.home
158 //
159 String josmHome = testProperties.getProperty("josm.home");
160 if (josmHome == null) {
161 fail(MessageFormat.format("property ''{0}'' not set in test environment", "josm.home"));
162 } else {
163 File f = new File(josmHome);
164 if (! f.exists() || ! f.canRead()) {
165 fail(MessageFormat.format("property ''{0}'' points to ''{1}'' which is either not existing or not readable", "josm.home", josmHome));
166 }
167 }
168
169 // check temp output dir
170 //
171 String tempOutputDir = testProperties.getProperty("test.functional.tempdir");
172 if (tempOutputDir == null) {
173 fail(MessageFormat.format("property ''{0}'' not set in test environment", "test.functional.tempdir"));
174 } else {
175 File f = new File(tempOutputDir);
176 if (! f.exists() || ! f.isDirectory() || ! f.canWrite()) {
177 fail(MessageFormat.format("property ''{0}'' points to ''{1}'' which is either not existing, not a directory, or not writeable", "test.functional.tempdir", tempOutputDir));
178 }
179 }
180
181
182 // init preferences
183 //
184 System.setProperty("josm.home", josmHome);
185 Main.pref.init(false);
186 // don't use atomic upload, the test API server can't cope with large diff uploads
187 //
188 Main.pref.put("osm-server.atomic-upload", false);
189 Main.proj = new Mercator();
190
191 File dataSetCacheOutputFile = new File(tempOutputDir, MultiFetchServerObjectReaderTest.class.getName() + ".dataset");
192
193 // make sure we don't upload to production
194 //
195 String url = OsmApi.getOsmApi().getBaseUrl().toLowerCase().trim();
196 if (url.startsWith("http://www.openstreetmap.org")
197 || url.startsWith("http://api.openstreetmap.org")) {
198 fail(MessageFormat.format("configured url ''{0}'' seems to be a productive url, aborting.", url));
199 }
200
201
202 String p = System.getProperties().getProperty("useCachedDataset");
203 if (p != null && Boolean.parseBoolean(p.trim().toLowerCase())) {
204 logger.info(MessageFormat.format("property ''{0}'' set, using cached dataset", "useCachedDataset"));
205 return;
206 }
207
208 logger.info(MessageFormat.format("property ''{0}'' not set to true, creating test dataset on the server. property is ''{1}''", "useCachedDataset", p));
209
210 // build and upload the test data set
211 //
212 logger.info("creating test data set ....");
213 testDataSet = buildTestDataSet();
214 logger.info("uploading test data set ...");
215 createDataSetOnServer(testDataSet);
216
217 PrintWriter pw = null;
218 try {
219 pw = new PrintWriter(
220 new FileWriter(dataSetCacheOutputFile)
221 );
222 } catch(IOException e) {
223 fail(MessageFormat.format("failed to open file ''{0}'' for writing", dataSetCacheOutputFile.toString()));
224 }
225 logger.info(MessageFormat.format("caching test data set in ''{0}'' ...", dataSetCacheOutputFile.toString()));
226 OsmWriter w = new OsmWriter(pw, false, testDataSet.version);
227 w.header();
228 w.writeDataSources(testDataSet);
229 w.writeContent(testDataSet);
230 w.footer();
231 w.close();
232 pw.close();
233 }
234
235 private DataSet ds;
236
237 @Before
238 public void setUp() throws IOException, SAXException {
239 File f = new File(testProperties.getProperty("test.functional.tempdir"), MultiFetchServerObjectReaderTest.class.getName() + ".dataset");
240 logger.info(MessageFormat.format("reading cached dataset ''{0}''", f.toString()));
241 ds = new DataSet();
242 FileInputStream fis = new FileInputStream(f);
243 ds = OsmReader.parseDataSet(fis, NullProgressMonitor.INSTANCE);
244 fis.close();
245 }
246
247 @Test
248 public void testBackrefrenceForNode() throws OsmTransferException {
249 Node n = lookupNode(ds, 0);
250 assertNotNull(n);
251 Way w = lookupWay(ds, 0);
252 assertNotNull(w);
253
254 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(n);
255 reader.setReadFull(false);
256 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
257 assertEquals(10, referers.nodes.size());
258 assertEquals(1, referers.ways.size());
259 assertEquals(0, referers.relations.size());
260 for (Way way: referers.ways) {
261 assertEquals(w.id, way.id);
262 assertEquals(false, way.incomplete);
263 }
264 }
265
266 @Test
267 public void testBackrefrenceForNode_Full() throws OsmTransferException {
268 Node n = lookupNode(ds, 0);
269 assertNotNull(n);
270 Way w = lookupWay(ds, 0);
271 assertNotNull(w);
272
273 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(n);
274 reader.setReadFull(true);
275 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
276 assertEquals(10, referers.nodes.size());
277 assertEquals(1, referers.ways.size());
278 assertEquals(0, referers.relations.size());
279 for (Way way: referers.ways) {
280 assertEquals(w.id, way.id);
281 assertEquals(false, way.incomplete);
282 assertEquals(10, w.nodes.size());
283 }
284 }
285
286 @Test
287 public void testBackrefrenceForWay() throws OsmTransferException {
288 Way w = lookupWay(ds, 1);
289 assertNotNull(w);
290 // way with name "way-1" is referred to by two relations
291 //
292
293 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(w);
294 reader.setReadFull(false);
295 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
296 assertEquals(0, referers.nodes.size()); // no nodes loaded
297 assertEquals(6, referers.ways.size()); // 6 ways referred by two relations
298 for (Way w1: referers.ways) {
299 assertEquals(true, w1.incomplete);
300 }
301 assertEquals(2, referers.relations.size()); // two relations referring to w
302
303 Relation r = lookupRelation(referers, 0);
304 assertNotNull(r);
305 assertEquals(false, r.incomplete);
306 r = lookupRelation(referers, 1);
307 assertEquals(false, r.incomplete);
308 }
309
310 @Test
311 public void testBackrefrenceForWay_Full() throws OsmTransferException {
312 Way w = lookupWay(ds, 1);
313 assertNotNull(w);
314 // way with name "way-1" is referred to by two relations
315 //
316
317 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(w);
318 reader.setReadFull(true);
319 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
320 assertEquals(6, referers.ways.size()); // 6 ways referred by two relations
321 for (Way w1: referers.ways) {
322 assertEquals(false, w1.incomplete);
323 }
324 assertEquals(2, referers.relations.size()); // two relations referring to
325 Set<Long> expectedNodeIds = new HashSet<Long>();
326 for (Way way: referers.ways) {
327 Way orig = (Way)ds.getPrimitiveById(way.id);
328 for(Node n: orig.nodes) {
329 expectedNodeIds.add(n.id);
330 }
331 }
332 assertEquals(expectedNodeIds.size(), referers.nodes.size());
333 for (Node n : referers.nodes) {
334 assertEquals(true, expectedNodeIds.contains(n.id));
335 }
336
337 Relation r = lookupRelation(referers, 0);
338 assertNotNull(r);
339 assertEquals(false, r.incomplete);
340 r = lookupRelation(referers, 1);
341 assertEquals(false, r.incomplete);
342 }
343
344 @Test
345 public void testBackrefrenceForRelation() throws OsmTransferException {
346 Relation r = lookupRelation(ds,1);
347 assertNotNull(r);
348 // way with name "relation-1" is referred to by four relations:
349 // relation-6, relation-7, relation-8, relation-9
350 //
351
352 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(r);
353 reader.setReadFull(false);
354 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
355
356 Set<Long> referringRelationsIds = new HashSet<Long>();
357 r = lookupRelation(referers, 6);
358 assertNotNull(r);
359 assertEquals(false, r.incomplete);
360 referringRelationsIds.add(r.id);
361 r = lookupRelation(referers, 7);
362 assertNotNull(r);
363 assertEquals(false, r.incomplete);
364 referringRelationsIds.add(r.id);
365 r = lookupRelation(referers, 8);
366 assertNotNull(r);
367 assertEquals(false, r.incomplete);
368 referringRelationsIds.add(r.id);
369 r = lookupRelation(referers, 9);
370 assertNotNull(r);
371 assertEquals(false, r.incomplete);
372 referringRelationsIds.add(r.id);
373
374 for (Relation r1: referers.relations) {
375 if (! referringRelationsIds.contains(r1.id)) {
376 assertEquals(true, r1.incomplete);
377 }
378 }
379
380 // make sure we read all ways referred to by parent relations. These
381 // ways are incomplete after reading.
382 //
383 Set<Long> expectedWayIds = new HashSet<Long>();
384 for (RelationMember m : lookupRelation(ds, 6).members) {
385 if (m.member instanceof Way) {
386 expectedWayIds.add(m.member.id);
387 }
388 }
389 for (RelationMember m : lookupRelation(ds, 7).members) {
390 if (m.member instanceof Way) {
391 expectedWayIds.add(m.member.id);
392 }
393 }
394 for (RelationMember m : lookupRelation(ds, 8).members) {
395 if (m.member instanceof Way) {
396 expectedWayIds.add(m.member.id);
397 }
398 }
399 for (RelationMember m : lookupRelation(ds, 9).members) {
400 if (m.member instanceof Way) {
401 expectedWayIds.add(m.member.id);
402 }
403 }
404
405 assertEquals(expectedWayIds.size(), referers.ways.size());
406 for (Way w1 : referers.ways) {
407 assertEquals(true, expectedWayIds.contains(w1.id));
408 assertEquals(true, w1.incomplete);
409 }
410
411 // make sure we didn't read any nodes
412 //
413 assertEquals(0, referers.nodes.size());
414 }
415
416 protected Set<Long> getNodeIdsInWay(Way way) {
417 HashSet<Long> ret = new HashSet<Long>();
418 if (way == null)return ret;
419 for (Node n: way.nodes) {
420 ret.add(n.id);
421 }
422 return ret;
423 }
424
425 protected Set<Long> getNodeIdsInRelation(Relation r) {
426 HashSet<Long> ret = new HashSet<Long>();
427 if (r == null) return ret;
428 for (RelationMember m: r.members) {
429 if (m.member instanceof Node) {
430 ret.add(m.member.id);
431 } else if (m.member instanceof Way) {
432 ret.addAll(getNodeIdsInWay((Way)m.member));
433 } else if (m.member instanceof Relation) {
434 ret.addAll(getNodeIdsInRelation((Relation)m.member));
435 }
436 }
437 return ret;
438 }
439
440 @Test
441 public void testBackrefrenceForRelation_Full() throws OsmTransferException {
442 Relation r = lookupRelation(ds,1);
443 assertNotNull(r);
444 // way with name "relation-1" is referred to by four relations:
445 // relation-6, relation-7, relation-8, relation-9
446 //
447
448 OsmServerBackreferenceReader reader = new OsmServerBackreferenceReader(r);
449 reader.setReadFull(true);
450 DataSet referers = reader.parseOsm(NullProgressMonitor.INSTANCE);
451
452 Set<Long> referringRelationsIds = new HashSet<Long>();
453 r = lookupRelation(referers, 6);
454 assertNotNull(r);
455 assertEquals(false, r.incomplete);
456 referringRelationsIds.add(r.id);
457 r = lookupRelation(referers, 7);
458 assertNotNull(r);
459 assertEquals(false, r.incomplete);
460 referringRelationsIds.add(r.id);
461 r = lookupRelation(referers, 8);
462 assertNotNull(r);
463 assertEquals(false, r.incomplete);
464 referringRelationsIds.add(r.id);
465 r = lookupRelation(referers, 9);
466 assertNotNull(r);
467 assertEquals(false, r.incomplete);
468 referringRelationsIds.add(r.id);
469
470 // all relations are fully loaded
471 //
472 for (Relation r1: referers.relations) {
473 assertEquals(false, r1.incomplete);
474 }
475
476 // make sure we read all ways referred to by parent relations. These
477 // ways are completely read after reading the relations
478 //
479 Set<Long> expectedWayIds = new HashSet<Long>();
480 for (RelationMember m : lookupRelation(ds, 6).members) {
481 if (m.member instanceof Way) {
482 expectedWayIds.add(m.member.id);
483 }
484 }
485 for (RelationMember m : lookupRelation(ds, 7).members) {
486 if (m.member instanceof Way) {
487 expectedWayIds.add(m.member.id);
488 }
489 }
490 for (RelationMember m : lookupRelation(ds, 8).members) {
491 if (m.member instanceof Way) {
492 expectedWayIds.add(m.member.id);
493 }
494 }
495 for (RelationMember m : lookupRelation(ds, 9).members) {
496 if (m.member instanceof Way) {
497 expectedWayIds.add(m.member.id);
498 }
499 }
500 for (long id : expectedWayIds) {
501 Way w = (Way)referers.getPrimitiveById(id);
502 assertNotNull(w);
503 assertEquals(false, w.incomplete);
504 }
505
506 Set<Long> expectedNodeIds = new HashSet<Long>();
507 for(int i=6; i< 10;i++) {
508 Relation r1 = lookupRelation(ds, i);
509 expectedNodeIds.addAll(getNodeIdsInRelation(r1));
510 }
511
512 assertEquals(expectedNodeIds.size(), referers.nodes.size());
513 for(Node n : referers.nodes) {
514 assertEquals(true, expectedNodeIds.contains(n.id));
515 }
516 }
517}
Note: See TracBrowser for help on using the repository browser.