1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
package com.vaadin.ui;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Stream;
import org.jsoup.nodes.Element;
import org.junit.Before;
import org.junit.Test;
import com.vaadin.data.HasDataProvider;
import com.vaadin.data.provider.DataProvider;
import com.vaadin.data.provider.ListDataProvider;
import com.vaadin.data.provider.Query;
import com.vaadin.ui.AbstractListing.AbstractListingExtension;
import com.vaadin.ui.declarative.DesignContext;
import elemental.json.JsonObject;
public class AbstractListingTest {
private final class TestListing extends AbstractSingleSelect<String>
implements HasDataProvider<String> {
/**
* Used to execute data generation
*
* @param initial
* {@code true} to mock initial data request; {@code false}
* for follow-up request.
*/
public void runDataGeneration(boolean initial) {
super.getDataCommunicator().beforeClientResponse(initial);
}
@Override
protected Element writeItem(Element design, String item,
DesignContext context) {
return null;
}
@Override
protected void readItems(Element design, DesignContext context) {
}
@Override
public DataProvider<String, ?> getDataProvider() {
return internalGetDataProvider();
}
@Override
public void setDataProvider(DataProvider<String, ?> dataProvider) {
internalSetDataProvider(dataProvider);
}
}
private final class CountGenerator
extends AbstractListingExtension<String> {
int callCount = 0;
@Override
public void generateData(String data, JsonObject jsonObject) {
++callCount;
}
@Override
public void destroyData(String data) {
}
@Override
public void refresh(String data) {
super.refresh(data);
}
}
private static final String[] ITEM_ARRAY = { "Foo", "Bar", "Baz" };
private TestListing listing;
private List<String> items;
@Before
public void setUp() {
items = new ArrayList<>(Arrays.asList(ITEM_ARRAY));
listing = new TestListing();
}
@Test
public void testSetItemsWithCollection() {
listing.setItems(items);
List<String> list = new LinkedList<>(items);
listing.getDataProvider().fetch(new Query())
.forEach(str -> assertTrue("Unexpected item in data provider",
list.remove(str)));
assertTrue("Not all items from list were in data provider",
list.isEmpty());
}
@Test
public void testSetItemsWithVarargs() {
listing.setItems(ITEM_ARRAY);
listing.getDataProvider().fetch(new Query())
.forEach(str -> assertTrue("Unexpected item in data provider",
items.remove(str)));
assertTrue("Not all items from list were in data provider",
items.isEmpty());
}
@Test
public void testSetDataProvider() {
ListDataProvider<String> dataProvider = DataProvider
.ofCollection(items);
listing.setDataProvider(dataProvider);
assertEquals("setDataProvider did not set data provider", dataProvider,
listing.getDataProvider());
listing.setDataProvider(
DataProvider.fromCallbacks(
query -> Stream.of(ITEM_ARRAY).skip(query.getOffset())
.limit(query.getLimit()),
query -> ITEM_ARRAY.length));
assertNotEquals("setDataProvider did not replace data provider",
dataProvider, listing.getDataProvider());
}
@Test
public void testAddDataGeneratorBeforeDataProvider() {
CountGenerator generator = new CountGenerator();
generator.extend(listing);
listing.setItems("Foo");
listing.runDataGeneration(true);
assertEquals("Generator should have been called once", 1,
generator.callCount);
}
@Test
public void testAddDataGeneratorAfterDataProvider() {
CountGenerator generator = new CountGenerator();
listing.setItems("Foo");
generator.extend(listing);
listing.runDataGeneration(true);
assertEquals("Generator should have been called once", 1,
generator.callCount);
}
@Test
public void testDataNotGeneratedTwice() {
listing.setItems("Foo");
CountGenerator generator = new CountGenerator();
generator.extend(listing);
listing.runDataGeneration(true);
assertEquals("Generator should have been called once", 1,
generator.callCount);
listing.runDataGeneration(false);
assertEquals("Generator should not have been called again", 1,
generator.callCount);
}
@Test
public void testRemoveDataGenerator() {
listing.setItems("Foo");
CountGenerator generator = new CountGenerator();
generator.extend(listing);
generator.remove();
listing.runDataGeneration(true);
assertEquals("Generator should not have been called", 0,
generator.callCount);
}
@Test
public void testDataRefresh() {
listing.setItems("Foo");
CountGenerator generator = new CountGenerator();
generator.extend(listing);
listing.runDataGeneration(true);
assertEquals("Generator should have been called once", 1,
generator.callCount);
generator.refresh("Foo");
listing.runDataGeneration(false);
assertEquals("Generator should have been called again", 2,
generator.callCount);
}
}
|
