juplo.de Git - maven-thymeleaf-skin/blob - src/test/java/de/juplo/jackson/SimpleMapperTest.java

   1 package de.juplo.jackson;
   2
   3 import com.fasterxml.jackson.core.JsonFactory;
   4 import com.fasterxml.jackson.core.JsonParser;
   5 import java.io.IOException;
   6 import java.io.InputStream;
   7 import java.util.ArrayList;
   8 import java.util.List;
   9 import java.util.Map;
  10 import java.util.Map.Entry;
  11 import java.util.Spliterator;
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertFalse;
  14 import static org.junit.Assert.assertNotNull;
  15 import static org.junit.Assert.assertNull;
  16 import static org.junit.Assert.assertTrue;
  17 import static org.junit.Assert.fail;
  18 import org.junit.Test;
  19 import org.slf4j.Logger;
  20 import org.slf4j.LoggerFactory;
  21 import static org.junit.Assert.assertEquals;
  22 import static org.junit.Assert.assertFalse;
  23 import static org.junit.Assert.assertNotNull;
  24 import static org.junit.Assert.assertNull;
  25 import static org.junit.Assert.assertTrue;
  26 import static org.junit.Assert.fail;
  27
  28
  29 /**
  30  *
  31  * @author Kai Moritz
  32  */
  33 public class SimpleMapperTest
  34 {
  35   private static final Logger LOG =
  36       LoggerFactory.getLogger(SimpleMapperTest.class);
  37
  38
  39   private final JsonFactory factory = new JsonFactory();
  40
  41
  42   @Test
  43   public void testConvertEmptyInputToArraySpliterator() throws Exception
  44   {
  45     Spliterator<Object> spliterator;
  46
  47     spliterator = SimpleMapper.getArraySpliterator(get("/empty/1.json"));
  48     assertNull(spliterator);
  49     spliterator = SimpleMapper.getArraySpliterator(get("/empty/2.json"));
  50     assertNull(spliterator);
  51     spliterator = SimpleMapper.getArraySpliterator(get("/empty/3.json"));
  52     assertNull(spliterator);
  53     spliterator = SimpleMapper.getArraySpliterator(get("/empty/4.json"));
  54     assertNull(spliterator);
  55     spliterator = SimpleMapper.getArraySpliterator(get("/empty/5.json"));
  56     assertNull(spliterator);
  57   }
  58
  59   @Test
  60   public void testConvertEmptyInputToList() throws Exception
  61   {
  62     List<Object> list;
  63
  64     list = SimpleMapper.convertArray(get("/empty/1.json"));
  65     assertNull(list);
  66     list = SimpleMapper.convertArray(get("/empty/2.json"));
  67     assertNull(list);
  68     list = SimpleMapper.convertArray(get("/empty/3.json"));
  69     assertNull(list);
  70     list = SimpleMapper.convertArray(get("/empty/4.json"));
  71     assertNull(list);
  72     list = SimpleMapper.convertArray(get("/empty/5.json"));
  73     assertNull(list);
  74   }
  75
  76   @Test
  77   public void testConvertEmptyInputToObjectSpliterator() throws Exception
  78   {
  79     Spliterator<Entry<String, Object>> spliterator;
  80
  81     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/1.json"));
  82     assertNull(spliterator);
  83     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/2.json"));
  84     assertNull(spliterator);
  85     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/3.json"));
  86     assertNull(spliterator);
  87     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/4.json"));
  88     assertNull(spliterator);
  89     spliterator = SimpleMapper.getObjectSpliterator(get("/empty/5.json"));
  90     assertNull(spliterator);
  91   }
  92
  93   @Test
  94   public void testConvertEmptyInputToMap() throws Exception
  95   {
  96     Map<String, Object> map;
  97
  98     map = SimpleMapper.convertObject(get("/empty/1.json"));
  99     assertNull(map);
 100     map = SimpleMapper.convertObject(get("/empty/2.json"));
 101     assertNull(map);
 102     map = SimpleMapper.convertObject(get("/empty/3.json"));
 103     assertNull(map);
 104     map = SimpleMapper.convertObject(get("/empty/4.json"));
 105     assertNull(map);
 106     map = SimpleMapper.convertObject(get("/empty/5.json"));
 107     assertNull(map);
 108   }
 109
 110   @Test
 111   public void testConvertEmptyInput() throws Exception
 112   {
 113     Object object;
 114
 115     object = SimpleMapper.convert(get("/empty/1.json"));
 116     assertNull(object);
 117     object = SimpleMapper.convert(get("/empty/2.json"));
 118     assertNull(object);
 119     object = SimpleMapper.convert(get("/empty/3.json"));
 120     assertNull(object);
 121     object = SimpleMapper.convert(get("/empty/4.json"));
 122     assertNull(object);
 123     object = SimpleMapper.convert(get("/empty/5.json"));
 124     assertNull(object);
 125   }
 126
 127
 128   @Test
 129   public void testConvertEmptyArrayToArraySpliterator() throws Exception
 130   {
 131     Spliterator<Object> spliterator;
 132
 133     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/1.json"));
 134     assertFalse(
 135         "The created splitter should have no entries",
 136         spliterator.tryAdvance((Object t) ->
 137         {
 138           fail("The consumer should never be called!");
 139         }));
 140     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/2.json"));
 141     assertFalse(
 142         "The created splitter should have no entries",
 143         spliterator.tryAdvance((Object t) ->
 144         {
 145           fail("The consumer should never be called!");
 146         }));
 147     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/3.json"));
 148     assertFalse(
 149         "The created splitter should have no entries",
 150         spliterator.tryAdvance((Object t) ->
 151         {
 152           fail("The consumer should never be called!");
 153         }));
 154     spliterator = SimpleMapper.getArraySpliterator(get("/array/empty/4.json"));
 155     assertFalse(
 156         "The created splitter should have no entries",
 157         spliterator.tryAdvance((Object t) ->
 158         {
 159           fail("The consumer should never be called!");
 160         }));
 161   }
 162
 163   @Test
 164   public void testConvertEmptyArrayToList() throws Exception
 165   {
 166     List<Object> list;
 167
 168     list = SimpleMapper.convertArray(get("/array/empty/1.json"));
 169     assertEquals(0, list.size());
 170     list = SimpleMapper.convertArray(get("/array/empty/2.json"));
 171     assertEquals(0, list.size());
 172     list = SimpleMapper.convertArray(get("/array/empty/3.json"));
 173     assertEquals(0, list.size());
 174     list = SimpleMapper.convertArray(get("/array/empty/4.json"));
 175     assertEquals(0, list.size());
 176   }
 177
 178   @Test
 179   public void testConvertEmptyArrayToObjectSpliterator() throws Exception
 180   {
 181     try
 182     {
 183       SimpleMapper.getObjectSpliterator(get("/array/empty/1.json"));
 184       fail("it must not be possible, to get an object-spliterator for an array");
 185     }
 186     catch(IllegalArgumentException e)
 187     {
 188       LOG.info(e.getMessage());
 189     }
 190
 191     try
 192     {
 193       SimpleMapper.getObjectSpliterator(get("/array/empty/2.json"));
 194       fail("it must not be possible, to get an object-spliterator for an array");
 195     }
 196     catch(IllegalArgumentException e)
 197     {
 198       LOG.info(e.getMessage());
 199     }
 200
 201     try
 202     {
 203       SimpleMapper.getObjectSpliterator(get("/array/empty/3.json"));
 204       fail("it must not be possible, to get an object-spliterator for an array");
 205     }
 206     catch(IllegalArgumentException e)
 207     {
 208       LOG.info(e.getMessage());
 209     }
 210
 211     try
 212     {
 213       SimpleMapper.getObjectSpliterator(get("/array/empty/4.json"));
 214       fail("it must not be possible, to get an object-spliterator for an array");
 215     }
 216     catch(IllegalArgumentException e)
 217     {
 218       LOG.info(e.getMessage());
 219     }
 220   }
 221
 222   @Test
 223   public void testConvertEmptyArrayToMap() throws Exception
 224   {
 225     try
 226     {
 227       SimpleMapper.convertObject(get("/array/empty/1.json"));
 228       fail("it must not be possible, to get a map for an array");
 229     }
 230     catch(IllegalArgumentException e)
 231     {
 232       LOG.info(e.getMessage());
 233     }
 234
 235     try
 236     {
 237       SimpleMapper.convertObject(get("/array/empty/2.json"));
 238       fail("it must not be possible, to get a map for an array");
 239     }
 240     catch(IllegalArgumentException e)
 241     {
 242       LOG.info(e.getMessage());
 243     }
 244
 245     try
 246     {
 247       SimpleMapper.convertObject(get("/array/empty/3.json"));
 248       fail("it must not be possible, to get a map for an array");
 249     }
 250     catch(IllegalArgumentException e)
 251     {
 252       LOG.info(e.getMessage());
 253     }
 254
 255     try
 256     {
 257       SimpleMapper.convertObject(get("/array/empty/4.json"));
 258       fail("it must not be possible, to get a map for an array");
 259     }
 260     catch(IllegalArgumentException e)
 261     {
 262       LOG.info(e.getMessage());
 263     }
 264   }
 265
 266   @Test
 267   public void testConvertEmptyArray() throws Exception
 268   {
 269     Object object;
 270
 271     object = SimpleMapper.convert(get("/array/empty/1.json"));
 272     assertNotNull(object);
 273     assertTrue("the returned object should be a list", object instanceof List);
 274     assertEquals(0, ((List)object).size());
 275     object = SimpleMapper.convert(get("/array/empty/2.json"));
 276     assertNotNull(object);
 277     assertTrue("the returned object should be a list", object instanceof List);
 278     assertEquals(0, ((List)object).size());
 279     object = SimpleMapper.convert(get("/array/empty/3.json"));
 280     assertNotNull(object);
 281     assertTrue("the returned object should be a list", object instanceof List);
 282     assertEquals(0, ((List)object).size());
 283     object = SimpleMapper.convert(get("/array/empty/4.json"));
 284     assertNotNull(object);
 285     assertTrue("the returned object should be a list", object instanceof List);
 286     assertEquals(0, ((List)object).size());
 287   }
 288
 289
 290   @Test
 291   public void testConvertEmptyObjectToArraySpliterator() throws Exception
 292   {
 293     try
 294     {
 295       SimpleMapper.getArraySpliterator(get("/object/empty/1.json"));
 296       fail("it must not be possible, to get an array-spliterator for an object");
 297     }
 298     catch(IllegalArgumentException e)
 299     {
 300       LOG.info(e.getMessage());
 301     }
 302
 303     try
 304     {
 305       SimpleMapper.getArraySpliterator(get("/object/empty/2.json"));
 306       fail("it must not be possible, to get an array-spliterator for an object");
 307     }
 308     catch(IllegalArgumentException e)
 309     {
 310       LOG.info(e.getMessage());
 311     }
 312
 313     try
 314     {
 315       SimpleMapper.getArraySpliterator(get("/object/empty/3.json"));
 316       fail("it must not be possible, to get an array-spliterator for an object");
 317     }
 318     catch(IllegalArgumentException e)
 319     {
 320       LOG.info(e.getMessage());
 321     }
 322
 323     try
 324     {
 325       SimpleMapper.getArraySpliterator(get("/object/empty/4.json"));
 326       fail("it must not be possible, to get an array-spliterator for an object");
 327     }
 328     catch(IllegalArgumentException e)
 329     {
 330       LOG.info(e.getMessage());
 331     }
 332   }
 333
 334   @Test
 335   public void testConvertEmptyObjectToList() throws Exception
 336   {
 337     try
 338     {
 339       SimpleMapper.convertArray(get("/object/empty/1.json"));
 340       fail("it must not be possible, to get a list for an array");
 341     }
 342     catch(IllegalArgumentException e)
 343     {
 344       LOG.info(e.getMessage());
 345     }
 346
 347     try
 348     {
 349       SimpleMapper.convertArray(get("/object/empty/2.json"));
 350       fail("it must not be possible, to get a list for an array");
 351     }
 352     catch(IllegalArgumentException e)
 353     {
 354       LOG.info(e.getMessage());
 355     }
 356
 357     try
 358     {
 359       SimpleMapper.convertArray(get("/object/empty/3.json"));
 360       fail("it must not be possible, to get a list for an array");
 361     }
 362     catch(IllegalArgumentException e)
 363     {
 364       LOG.info(e.getMessage());
 365     }
 366
 367     try
 368     {
 369       SimpleMapper.convertArray(get("/object/empty/4.json"));
 370       fail("it must not be possible, to get a list for an array");
 371     }
 372     catch(IllegalArgumentException e)
 373     {
 374       LOG.info(e.getMessage());
 375     }
 376   }
 377
 378   @Test
 379   public void testConvertEmptyObjectToObjectSpliterator() throws Exception
 380   {
 381     Spliterator<Entry<String, Object>> spliterator;
 382
 383     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/1.json"));
 384     assertFalse(
 385         "The created splitter should have no entries",
 386         spliterator.tryAdvance((Entry<String, Object> e) ->
 387         {
 388           fail("The consumer should never be called!");
 389         }));
 390     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/2.json"));
 391     assertFalse(
 392         "The created splitter should have no entries",
 393         spliterator.tryAdvance((Entry<String, Object> e) ->
 394         {
 395           fail("The consumer should never be called!");
 396         }));
 397     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/3.json"));
 398     assertFalse(
 399         "The created splitter should have no entries",
 400         spliterator.tryAdvance((Entry<String, Object> e) ->
 401         {
 402           fail("The consumer should never be called!");
 403         }));
 404     spliterator = SimpleMapper.getObjectSpliterator(get("/object/empty/4.json"));
 405     assertFalse(
 406         "The created splitter should have no entries",
 407         spliterator.tryAdvance((Entry<String, Object> e) ->
 408         {
 409           fail("The consumer should never be called!");
 410         }));
 411   }
 412
 413   @Test
 414   public void testConvertEmptyObjectToMap() throws Exception
 415   {
 416     Map<String, Object> map;
 417
 418     map = SimpleMapper.convertObject(get("/object/empty/1.json"));
 419     assertEquals(0, map.size());
 420     map = SimpleMapper.convertObject(get("/object/empty/2.json"));
 421     assertEquals(0, map.size());
 422     map = SimpleMapper.convertObject(get("/object/empty/3.json"));
 423     assertEquals(0, map.size());
 424     map = SimpleMapper.convertObject(get("/object/empty/4.json"));
 425     assertEquals(0, map.size());
 426   }
 427
 428   @Test
 429   public void testConvertEmptyObject() throws Exception
 430   {
 431     Object object;
 432
 433     object = SimpleMapper.convert(get("/object/empty/1.json"));
 434     assertNotNull(object);
 435     assertTrue("the returned object should be a list", object instanceof Map);
 436     assertEquals(0, ((Map)object).size());
 437     object = SimpleMapper.convert(get("/object/empty/2.json"));
 438     assertNotNull(object);
 439     assertTrue("the returned object should be a list", object instanceof Map);
 440     assertEquals(0, ((Map)object).size());
 441     object = SimpleMapper.convert(get("/object/empty/3.json"));
 442     assertNotNull(object);
 443     assertTrue("the returned object should be a list", object instanceof Map);
 444     assertEquals(0, ((Map)object).size());
 445     object = SimpleMapper.convert(get("/object/empty/4.json"));
 446     assertNotNull(object);
 447     assertTrue("the returned object should be a list", object instanceof Map);
 448     assertEquals(0, ((Map)object).size());
 449   }
 450
 451
 452   @Test
 453   public void testConvertArrayToArraySpliterator() throws Exception
 454   {
 455     Spliterator<Object> spliterator;
 456
 457     spliterator = SimpleMapper.getArraySpliterator(get("/array/1.json"));
 458     checkArraySpliterator(spliterator);
 459     spliterator = SimpleMapper.getArraySpliterator(get("/array/2.json"));
 460     checkArraySpliterator(spliterator);
 461   }
 462
 463   void checkArraySpliterator(Spliterator<Object> spliterator) throws Exception
 464   {
 465     assertNotNull(spliterator);
 466
 467     final ArrayList<Object> entries = new ArrayList<>(4);
 468     for (int i = 0; i < 4; i++)
 469       assertTrue(
 470           "The created splitter should have a " + (i+1) + ". entry",
 471           spliterator.tryAdvance((Object t) -> { entries.add(t); })
 472           );
 473
 474     assertFalse(
 475         "The created splitter should have no more entries",
 476         spliterator.tryAdvance((Object t) ->
 477         {
 478           fail("The consumer should not have been called");
 479         }));
 480
 481     checkPartnerPageData(entries.get(3));
 482   }
 483
 484   @Test
 485   public void testConvertArrayToList() throws Exception
 486   {
 487     List<Object> list;
 488
 489     list = SimpleMapper.convertArray(get("/array/1.json"));
 490     assertNotNull(list);
 491     assertEquals(4, list.size());
 492     checkPartnerPageData(list.get(3));
 493     list = SimpleMapper.convertArray(get("/array/2.json"));
 494     assertNotNull(list);
 495     assertEquals(4, list.size());
 496     checkPartnerPageData(list.get(3));
 497   }
 498
 499   @Test
 500   public void testConvertArrayToObjectSpliterator() throws Exception
 501   {
 502     try
 503     {
 504       SimpleMapper.getObjectSpliterator(get("/array/1.json"));
 505       fail("it must not be possible, to get an object-spliterator for an array");
 506     }
 507     catch(IllegalArgumentException e)
 508     {
 509       LOG.info(e.getMessage());
 510     }
 511
 512     try
 513     {
 514       SimpleMapper.getObjectSpliterator(get("/array/2.json"));
 515       fail("it must not be possible, to get an object-spliterator for an array");
 516     }
 517     catch(IllegalArgumentException e)
 518     {
 519       LOG.info(e.getMessage());
 520     }
 521   }
 522
 523   @Test
 524   public void testConvertArrayToMap() throws Exception
 525   {
 526     try
 527     {
 528       SimpleMapper.convertObject(get("/array/1.json"));
 529       fail("it must not be possible, to get a map for an array");
 530     }
 531     catch(IllegalArgumentException e)
 532     {
 533       LOG.info(e.getMessage());
 534     }
 535
 536     try
 537     {
 538       SimpleMapper.convertObject(get("/array/2.json"));
 539       fail("it must not be possible, to get a map for an array");
 540     }
 541     catch(IllegalArgumentException e)
 542     {
 543       LOG.info(e.getMessage());
 544     }
 545   }
 546
 547   @Test
 548   public void testConvertArray() throws Exception
 549   {
 550     Object object;
 551     List<Object> list;
 552
 553     object = SimpleMapper.convert(get("/array/1.json"));
 554     assertNotNull(object);
 555     assertTrue("the returned object should be a list", object instanceof List);
 556     list = (List<Object>)object;
 557     assertEquals(4, list.size());
 558     checkPartnerPageData(list.get(3));
 559     object = SimpleMapper.convert(get("/array/2.json"));
 560     assertNotNull(object);
 561     assertTrue("the returned object should be a list", object instanceof List);
 562     list = (List<Object>)object;
 563     assertEquals(4, list.size());
 564     checkPartnerPageData(list.get(3));
 565   }
 566
 567   void checkPartnerPageData(Object page)
 568   {
 569     assertTrue("The page-data should be of type Map", page instanceof Map);
 570     Map<String, Object> map = (Map<String, Object>)page;
 571     assertEquals(4, map.size());
 572     assertEquals("/partner.html", map.get("uri"));
 573     assertTrue(
 574         "The page-data should have an entry \"children\" of type Map",
 575         map.get("children") instanceof Map
 576         );
 577     map = (Map<String, Object>)map.get("children");
 578     assertEquals(6, map.size());
 579     assertTrue(
 580         "The children-map should haven an entry \"/partner/juplo.html\" of type Map",
 581         map.get("/partner/juplo.html") instanceof Map
 582         );
 583     map = (Map<String, Object>)map.get("/partner/juplo.html");
 584     assertEquals(2, map.size());
 585     assertEquals(
 586         "Wir sind Unterstützer der Nerd-Plattform juplo.de",
 587         map.get("title")
 588         );
 589   }
 590
 591
 592   private JsonParser get(String resource) throws IOException
 593   {
 594     InputStream is = SimpleMapperTest.class.getResourceAsStream(resource);
 595     return factory.createParser(is);
 596   }
 597 }