source.dussan.org Git - vaadin-framework.git/blob

   1 /*
   2  * Copyright 2000-2016 Vaadin Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
   5  * use this file except in compliance with the License. You may obtain a copy of
   6  * the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13  * License for the specific language governing permissions and limitations under
  14  * the License.
  15  */
  16 package com.vaadin.v7.tests.server.component.calendar;
  17
  18 import static org.junit.Assert.assertEquals;
  19 import static org.junit.Assert.assertTrue;
  20
  21 import java.util.Date;
  22 import java.util.List;
  23
  24 import org.junit.Before;
  25 import org.junit.Test;
  26
  27 import com.vaadin.v7.data.Container.Indexed;
  28 import com.vaadin.v7.data.Container.Sortable;
  29 import com.vaadin.v7.data.Item;
  30 import com.vaadin.v7.data.Property;
  31 import com.vaadin.v7.data.util.BeanItemContainer;
  32 import com.vaadin.v7.data.util.IndexedContainer;
  33 import com.vaadin.v7.ui.Calendar;
  34 import com.vaadin.v7.ui.components.calendar.ContainerEventProvider;
  35 import com.vaadin.v7.ui.components.calendar.event.BasicEvent;
  36 import com.vaadin.v7.ui.components.calendar.event.CalendarEvent;
  37
  38 public class ContainerDataSourceTest {
  39
  40     private Calendar calendar;
  41
  42     @Before
  43     public void setUp() {
  44         calendar = new Calendar();
  45     }
  46
  47     /**
  48      * Tests adding a bean item container to the Calendar
  49      */
  50     @Test
  51     public void testWithBeanItemContainer() {
  52
  53         // Create a container to use as a datasource
  54         Indexed container = createTestBeanItemContainer();
  55
  56         // Set datasource
  57         calendar.setContainerDataSource(container);
  58
  59         // Start and end dates to query for
  60         java.util.Calendar cal = java.util.Calendar.getInstance();
  61         cal.setTime(((CalendarEvent) container.getIdByIndex(0)).getStart());
  62         Date start = cal.getTime();
  63         cal.add(java.util.Calendar.MONTH, 1);
  64         Date end = cal.getTime();
  65
  66         // Test the all events are returned
  67         List<CalendarEvent> events = calendar.getEventProvider()
  68                 .getEvents(start, end);
  69         assertEquals(container.size(), events.size());
  70
  71         // Test that a certain range is returned
  72         cal.setTime(((CalendarEvent) container.getIdByIndex(6)).getStart());
  73         end = cal.getTime();
  74         events = calendar.getEventProvider().getEvents(start, end);
  75         assertEquals(6, events.size());
  76     }
  77
  78     /**
  79      * This tests tests that if you give the Calendar an unsorted (== not sorted
  80      * by starting date) container then the calendar should gracefully handle
  81      * it. In this case the size of the container will be wrong. The test is
  82      * exactly the same as {@link #testWithBeanItemContainer()} except that the
  83      * beans has been intentionally sorted by caption instead of date.
  84      */
  85     @Test
  86     public void testWithUnsortedBeanItemContainer() {
  87         // Create a container to use as a datasource
  88         Indexed container = createTestBeanItemContainer();
  89
  90         // Make the container sorted by caption
  91         ((Sortable) container).sort(new Object[] { "caption" },
  92                 new boolean[] { true });
  93
  94         // Set data source
  95         calendar.setContainerDataSource(container);
  96
  97         // Start and end dates to query for
  98         java.util.Calendar cal = java.util.Calendar.getInstance();
  99         cal.setTime(((CalendarEvent) container.getIdByIndex(0)).getStart());
 100         Date start = cal.getTime();
 101         cal.add(java.util.Calendar.MONTH, 1);
 102         Date end = cal.getTime();
 103
 104         // Test the all events are returned
 105         List<CalendarEvent> events = calendar.getEventProvider()
 106                 .getEvents(start, end);
 107         assertEquals(container.size(), events.size());
 108
 109         // Test that a certain range is returned
 110         cal.setTime(((CalendarEvent) container.getIdByIndex(6)).getStart());
 111         end = cal.getTime();
 112         events = calendar.getEventProvider().getEvents(start, end);
 113
 114         // The events size is 1 since the getEvents returns the wrong range
 115         assertEquals(1, events.size());
 116     }
 117
 118     /**
 119      * Tests adding a Indexed container to the Calendar
 120      */
 121     @Test
 122     public void testWithIndexedContainer() {
 123
 124         // Create a container to use as a datasource
 125         Indexed container = createTestIndexedContainer();
 126
 127         // Set datasource
 128         calendar.setContainerDataSource(container, "testCaption",
 129                 "testDescription", "testStartDate", "testEndDate", null);
 130
 131         // Start and end dates to query for
 132         java.util.Calendar cal = java.util.Calendar.getInstance();
 133         cal.setTime((Date) container.getItem(container.getIdByIndex(0))
 134                 .getItemProperty("testStartDate").getValue());
 135         Date start = cal.getTime();
 136         cal.add(java.util.Calendar.MONTH, 1);
 137         Date end = cal.getTime();
 138
 139         // Test the all events are returned
 140         List<CalendarEvent> events = calendar.getEventProvider()
 141                 .getEvents(start, end);
 142         assertEquals(container.size(), events.size());
 143
 144         // Check that event values are present
 145         CalendarEvent e = events.get(0);
 146         assertEquals("Test 1", e.getCaption());
 147         assertEquals("Description 1", e.getDescription());
 148         assertTrue(e.getStart().compareTo(start) == 0);
 149
 150         // Test that a certain range is returned
 151         cal.setTime((Date) container.getItem(container.getIdByIndex(6))
 152                 .getItemProperty("testStartDate").getValue());
 153         end = cal.getTime();
 154         events = calendar.getEventProvider().getEvents(start, end);
 155         assertEquals(6, events.size());
 156     }
 157
 158     @Test
 159     public void testNullLimitsBeanItemContainer() {
 160         // Create a container to use as a datasource
 161         Indexed container = createTestBeanItemContainer();
 162
 163         // Start and end dates to query for
 164         java.util.Calendar cal = java.util.Calendar.getInstance();
 165         cal.setTime(((CalendarEvent) container.getIdByIndex(0)).getStart());
 166         Date start = cal.getTime();
 167         cal.add(java.util.Calendar.MONTH, 1);
 168         Date end = cal.getTime();
 169
 170         // Set datasource
 171         calendar.setContainerDataSource(container);
 172
 173         // Test null start time
 174         List<CalendarEvent> events = calendar.getEventProvider().getEvents(null,
 175                 end);
 176         assertEquals(container.size(), events.size());
 177
 178         // Test null end time
 179         events = calendar.getEventProvider().getEvents(start, null);
 180         assertEquals(container.size(), events.size());
 181
 182         // Test both null times
 183         events = calendar.getEventProvider().getEvents(null, null);
 184         assertEquals(container.size(), events.size());
 185     }
 186
 187     @Test
 188     public void testNullLimitsIndexedContainer() {
 189         // Create a container to use as a datasource
 190         Indexed container = createTestIndexedContainer();
 191
 192         // Start and end dates to query for
 193         java.util.Calendar cal = java.util.Calendar.getInstance();
 194         cal.setTime((Date) container.getItem(container.getIdByIndex(0))
 195                 .getItemProperty("testStartDate").getValue());
 196         Date start = cal.getTime();
 197         cal.add(java.util.Calendar.MONTH, 1);
 198         Date end = cal.getTime();
 199
 200         // Set datasource
 201         calendar.setContainerDataSource(container, "testCaption",
 202                 "testDescription", "testStartDate", "testEndDate", null);
 203
 204         // Test null start time
 205         List<CalendarEvent> events = calendar.getEventProvider().getEvents(null,
 206                 end);
 207         assertEquals(container.size(), events.size());
 208
 209         // Test null end time
 210         events = calendar.getEventProvider().getEvents(start, null);
 211         assertEquals(container.size(), events.size());
 212
 213         // Test both null times
 214         events = calendar.getEventProvider().getEvents(null, null);
 215         assertEquals(container.size(), events.size());
 216     }
 217
 218     /**
 219      * Tests the addEvent convenience method with the default event provider
 220      */
 221     @Test
 222     public void testAddEventConvinienceMethod() {
 223
 224         // Start and end dates to query for
 225         java.util.Calendar cal = java.util.Calendar.getInstance();
 226         Date start = cal.getTime();
 227         cal.add(java.util.Calendar.MONTH, 1);
 228         Date end = cal.getTime();
 229
 230         // Ensure no events
 231         assertEquals(0, calendar.getEvents(start, end).size());
 232
 233         // Add an event
 234         BasicEvent event = new BasicEvent("Test", "Test", start);
 235         calendar.addEvent(event);
 236
 237         // Ensure event exists
 238         List<CalendarEvent> events = calendar.getEvents(start, end);
 239         assertEquals(1, events.size());
 240         assertEquals(events.get(0).getCaption(), event.getCaption());
 241         assertEquals(events.get(0).getDescription(), event.getDescription());
 242         assertEquals(events.get(0).getStart(), event.getStart());
 243     }
 244
 245     /**
 246      * Test the removeEvent convenience method with the default event provider
 247      */
 248     @Test
 249     public void testRemoveEventConvinienceMethod() {
 250
 251         // Start and end dates to query for
 252         java.util.Calendar cal = java.util.Calendar.getInstance();
 253         Date start = cal.getTime();
 254         cal.add(java.util.Calendar.MONTH, 1);
 255         Date end = cal.getTime();
 256
 257         // Ensure no events
 258         assertEquals(0, calendar.getEvents(start, end).size());
 259
 260         // Add an event
 261         CalendarEvent event = new BasicEvent("Test", "Test", start);
 262         calendar.addEvent(event);
 263
 264         // Ensure event exists
 265         assertEquals(1, calendar.getEvents(start, end).size());
 266
 267         // Remove event
 268         calendar.removeEvent(event);
 269
 270         // Ensure no events
 271         assertEquals(0, calendar.getEvents(start, end).size());
 272     }
 273
 274     @Test
 275     public void testAddEventConvinienceMethodWithCustomEventProvider() {
 276
 277         // Use a container data source
 278         calendar.setEventProvider(new ContainerEventProvider(
 279                 new BeanItemContainer<BasicEvent>(BasicEvent.class)));
 280
 281         // Start and end dates to query for
 282         java.util.Calendar cal = java.util.Calendar.getInstance();
 283         Date start = cal.getTime();
 284         cal.add(java.util.Calendar.MONTH, 1);
 285         Date end = cal.getTime();
 286
 287         // Ensure no events
 288         assertEquals(0, calendar.getEvents(start, end).size());
 289
 290         // Add an event
 291         BasicEvent event = new BasicEvent("Test", "Test", start);
 292         calendar.addEvent(event);
 293
 294         // Ensure event exists
 295         List<CalendarEvent> events = calendar.getEvents(start, end);
 296         assertEquals(1, events.size());
 297         assertEquals(events.get(0).getCaption(), event.getCaption());
 298         assertEquals(events.get(0).getDescription(), event.getDescription());
 299         assertEquals(events.get(0).getStart(), event.getStart());
 300     }
 301
 302     @Test
 303     public void testRemoveEventConvinienceMethodWithCustomEventProvider() {
 304
 305         // Use a container data source
 306         calendar.setEventProvider(new ContainerEventProvider(
 307                 new BeanItemContainer<BasicEvent>(BasicEvent.class)));
 308
 309         // Start and end dates to query for
 310         java.util.Calendar cal = java.util.Calendar.getInstance();
 311         Date start = cal.getTime();
 312         cal.add(java.util.Calendar.MONTH, 1);
 313         Date end = cal.getTime();
 314
 315         // Ensure no events
 316         assertEquals(0, calendar.getEvents(start, end).size());
 317
 318         // Add an event
 319         BasicEvent event = new BasicEvent("Test", "Test", start);
 320         calendar.addEvent(event);
 321
 322         // Ensure event exists
 323         List<CalendarEvent> events = calendar.getEvents(start, end);
 324         assertEquals(1, events.size());
 325
 326         // Remove event
 327         calendar.removeEvent(event);
 328
 329         // Ensure no events
 330         assertEquals(0, calendar.getEvents(start, end).size());
 331     }
 332
 333     @Test
 334     public void testStyleNamePropertyRetrieved() {
 335         IndexedContainer ic = (IndexedContainer) createTestIndexedContainer();
 336         ic.addContainerProperty("testStyleName", String.class, "");
 337         for (int i = 0; i < 10; i++) {
 338             Item item = ic.getItem(ic.getIdByIndex(i));
 339             @SuppressWarnings("unchecked")
 340             Property<String> itemProperty = item
 341                     .getItemProperty("testStyleName");
 342             itemProperty.setValue("testStyle");
 343         }
 344
 345         ContainerEventProvider provider = new ContainerEventProvider(ic);
 346         provider.setCaptionProperty("testCaption");
 347         provider.setDescriptionProperty("testDescription");
 348         provider.setStartDateProperty("testStartDate");
 349         provider.setEndDateProperty("testEndDate");
 350         provider.setStyleNameProperty("testStyleName");
 351
 352         calendar.setEventProvider(provider);
 353         java.util.Calendar cal = java.util.Calendar.getInstance();
 354         Date now = cal.getTime();
 355         cal.add(java.util.Calendar.DAY_OF_MONTH, 20);
 356         Date then = cal.getTime();
 357         List<CalendarEvent> events = calendar.getEventProvider().getEvents(now,
 358                 then);
 359         for (CalendarEvent ce : events) {
 360             assertEquals("testStyle", ce.getStyleName());
 361         }
 362     }
 363
 364     private static Indexed createTestBeanItemContainer() {
 365         BeanItemContainer<CalendarEvent> eventContainer = new BeanItemContainer<CalendarEvent>(
 366                 CalendarEvent.class);
 367         java.util.Calendar cal = java.util.Calendar.getInstance();
 368         for (int i = 1; i <= 10; i++) {
 369             eventContainer.addBean(new BasicEvent("Test " + i,
 370                     "Description " + i, cal.getTime()));
 371             cal.add(java.util.Calendar.DAY_OF_MONTH, 2);
 372         }
 373         return eventContainer;
 374     }
 375
 376     private static Indexed createTestIndexedContainer() {
 377         IndexedContainer container = new IndexedContainer();
 378         container.addContainerProperty("testCaption", String.class, "");
 379         container.addContainerProperty("testDescription", String.class, "");
 380         container.addContainerProperty("testStartDate", Date.class, null);
 381         container.addContainerProperty("testEndDate", Date.class, null);
 382
 383         java.util.Calendar cal = java.util.Calendar.getInstance();
 384         for (int i = 1; i <= 10; i++) {
 385             Item item = container.getItem(container.addItem());
 386             item.getItemProperty("testCaption").setValue("Test " + i);
 387             item.getItemProperty("testDescription")
 388                     .setValue("Description " + i);
 389             item.getItemProperty("testStartDate").setValue(cal.getTime());
 390             item.getItemProperty("testEndDate").setValue(cal.getTime());
 391             cal.add(java.util.Calendar.DAY_OF_MONTH, 2);
 392         }
 393         return container;
 394     }
 395
 396 }