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

Last change on this file since 2498 was 2498, checked in by jttt, 14 years ago

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