1/*
2 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23package test.rowset.webrowset;
24
25import java.io.ByteArrayInputStream;
26import java.io.ByteArrayOutputStream;
27import java.io.File;
28import java.io.FileInputStream;
29import java.io.FileReader;
30import java.io.InputStreamReader;
31import java.io.ObjectInputStream;
32import java.io.ObjectOutputStream;
33import java.io.OutputStreamWriter;
34import java.math.BigDecimal;
35import java.sql.ResultSet;
36import java.util.Arrays;
37import javax.sql.rowset.WebRowSet;
38import static org.testng.Assert.assertEquals;
39import static org.testng.Assert.assertEqualsNoOrder;
40import static org.testng.Assert.assertFalse;
41import static org.testng.Assert.assertTrue;
42import org.testng.annotations.Test;
43import test.rowset.cachedrowset.CommonCachedRowSetTests;
44
45public abstract class CommonWebRowSetTests extends CommonCachedRowSetTests {
46
47    protected final String XMLFILEPATH = System.getProperty("test.src", ".")
48            + File.separatorChar + "xml" + File.separatorChar;
49    protected final String COFFEE_ROWS_XML = XMLFILEPATH + "COFFEE_ROWS.xml";
50    protected final String DELETED_COFFEE_ROWS_XML
51            = XMLFILEPATH + "DELETED_COFFEE_ROWS.xml";
52    protected final String MODFIED_DELETED_COFFEE_ROWS_XML
53            = XMLFILEPATH + "MODFIED_DELETED_COFFEE_ROWS.xml";
54    protected final String UPDATED_COFFEE_ROWS_XML
55            = XMLFILEPATH + "UPDATED_COFFEE_ROWS.xml";
56    protected final String INSERTED_COFFEE_ROWS_XML
57            = XMLFILEPATH + "INSERTED_COFFEE_ROWS.xml";
58    protected final String UPDATED_INSERTED_COFFEE_ROWS_XML
59            = XMLFILEPATH + "UPDATED_INSERTED_COFFEE_ROWS.xml";
60
61
62    /*
63     * Utility method to write a WebRowSet XML file via an OutputStream
64     */
65    protected ByteArrayOutputStream writeWebRowSetWithOutputStream(WebRowSet rs) throws Exception {
66        ByteArrayOutputStream baos = new ByteArrayOutputStream();
67        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
68            rs.writeXml(oos);
69        }
70        return baos;
71    }
72
73    /*
74     * Utility method to write a WebRowSet XML file via an OutputStream
75     * and populating the WebRowSet via a ResultSet
76     */
77    protected ByteArrayOutputStream writeWebRowSetWithOutputStream(ResultSet rs) throws Exception {
78        ByteArrayOutputStream baos = new ByteArrayOutputStream();
79        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
80            WebRowSet wrs = rsf.createWebRowSet();
81            wrs.writeXml(rs, oos);
82        }
83        return baos;
84    }
85
86
87    /*
88     * Utility method to popoulate a WebRowSet via a InputStream
89     */
90    protected WebRowSet readWebRowSetWithOInputStream(ByteArrayOutputStream baos) throws Exception {
91        WebRowSet wrs1 = rsf.createWebRowSet();
92        try (ObjectInputStream ois
93                = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()))) {
94            wrs1.readXml(ois);
95        }
96        return wrs1;
97    }
98
99    /*
100     * Utility method to write a WebRowSet XML file via an Writer
101     */
102    protected ByteArrayOutputStream writeWebRowSetWithOutputStreamWithWriter(WebRowSet rs) throws Exception {
103        ByteArrayOutputStream baos = new ByteArrayOutputStream();
104        OutputStreamWriter osw = new OutputStreamWriter(baos);
105        rs.writeXml(osw);
106        return baos;
107    }
108
109    /*
110     * Utility method to write a WebRowSet XML file via an Writer and populating
111     * the WebRowSet via a ResultSet
112     */
113    protected ByteArrayOutputStream writeWebRowSetWithOutputStreamWithWriter(ResultSet rs) throws Exception {
114        ByteArrayOutputStream baos = new ByteArrayOutputStream();
115        OutputStreamWriter osw = new OutputStreamWriter(baos);
116        WebRowSet wrs = rsf.createWebRowSet();
117        wrs.writeXml(rs, osw);
118        return baos;
119    }
120
121    /*
122     * Utility method to popoulate a WebRowSet via a Readar
123     */
124    protected WebRowSet readWebRowSetWithOInputStreamWithReader(ByteArrayOutputStream baos) throws Exception {
125        WebRowSet wrs1 = rsf.createWebRowSet();
126        InputStreamReader isr = new InputStreamReader(new ByteArrayInputStream(baos.toByteArray()));
127        wrs1.readXml(isr);
128        return wrs1;
129    }
130
131    /*
132     * Validate the expected Rows are contained within the RowSet
133     */
134    @Test(dataProvider = "rowsetUsingCoffees")
135    public void WebRowSetTest0000(WebRowSet wrs) throws Exception {
136        assertEquals(getPrimaryKeys(wrs), COFFEES_PRIMARY_KEYS);
137        assertEquals(wrs.size(), COFFEES_ROWS);
138        wrs.close();
139    }
140
141    /*
142     * Validate the expected Rows are contained within the RowSet
143     * populated by readXML(Reader)
144     */
145    @Test(dataProvider = "rowSetType")
146    public void WebRowSetTest0001(WebRowSet wrs1) throws Exception {
147
148        try (FileReader fr = new FileReader(COFFEE_ROWS_XML)) {
149            wrs1.readXml(fr);
150        }
151        assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS);
152        assertEquals(wrs1.size(), COFFEES_ROWS);
153        wrs1.close();
154
155    }
156
157    /*
158     * Validate the expected Rows are contained within the RowSet
159     * populated by readXML(InputStream)
160     */
161    @Test(dataProvider = "rowSetType")
162    public void WebRowSetTest0002(WebRowSet wrs1) throws Exception {
163        try (FileInputStream fis = new FileInputStream(COFFEE_ROWS_XML)) {
164            wrs1.readXml(fis);
165        }
166        assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS);
167        assertEquals(wrs1.size(), COFFEES_ROWS);
168        wrs1.close();
169    }
170
171    /*
172     * Write a WebRowSet via writeXML(OutputStream), read it
173     * back via readXML(InputStream) and validate the primary  keys
174     * are the same
175     */
176    @Test(dataProvider = "rowsetUsingCoffees")
177    public void WebRowSetTest0003(WebRowSet wrs) throws Exception {
178        ByteArrayOutputStream baos = writeWebRowSetWithOutputStream(wrs);
179        try (WebRowSet wrs1 = readWebRowSetWithOInputStream(baos)) {
180            assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS);
181            assertEquals(wrs1.size(), COFFEES_ROWS);
182        }
183    }
184
185    /*
186     * Write a ResultSet via writeXML(OutputStream), read it
187     * back via readXML(InputStream) and validate the primary  keys
188     * are the same
189     */
190    @Test(dataProvider = "rowsetUsingCoffees")
191    public void WebRowSetTest0004(WebRowSet wrs) throws Exception {
192        ResultSet rs = wrs;
193        rs.beforeFirst();
194        ByteArrayOutputStream baos = writeWebRowSetWithOutputStream(rs);
195        try (WebRowSet wrs1 = readWebRowSetWithOInputStream(baos)) {
196            assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS);
197            assertEquals(wrs1.size(), COFFEES_ROWS);
198        }
199    }
200
201    /*
202     * Write a WebRowSet via writeXML(Writer), read it
203     * back via readXML(Reader) and validate the primary  keys
204     * are the same
205     */
206    @Test(dataProvider = "rowsetUsingCoffees")
207    public void WebRowSetTest0005(WebRowSet wrs) throws Exception {
208        ByteArrayOutputStream baos = writeWebRowSetWithOutputStreamWithWriter(wrs);
209        try (WebRowSet wrs1 = readWebRowSetWithOInputStreamWithReader(baos)) {
210            assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS);
211            assertEquals(wrs1.size(), COFFEES_ROWS);
212        }
213    }
214
215    /*
216     * Write a WebRowSet via writeXML(Writer), read it
217     * back via readXML(Reader) and validate the primary  keys
218     * are the same
219     */
220    @Test(dataProvider = "rowsetUsingCoffees")
221    public void WebRowSetTest0006(WebRowSet wrs) throws Exception {
222        ResultSet rs = wrs;
223        rs.beforeFirst();
224        ByteArrayOutputStream baos = writeWebRowSetWithOutputStreamWithWriter(rs);
225        try (WebRowSet wrs1 = readWebRowSetWithOInputStreamWithReader(baos)) {
226            assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS);
227            assertEquals(wrs1.size(), COFFEES_ROWS);
228        }
229    }
230
231    /*
232     * Validate the expected Rows are contained within the RowSet
233     * after deleting the specified rows
234     */
235    @Test(dataProvider = "rowsetUsingCoffees", enabled = false)
236    public void WebRowSetTest0007(WebRowSet wrs) throws Exception {
237        assertEquals(getPrimaryKeys(wrs), COFFEES_PRIMARY_KEYS);
238        int[] rowsToDelete = {2, 4};
239        assertEquals(getPrimaryKeys(wrs), COFFEES_PRIMARY_KEYS);
240        for (int row : rowsToDelete) {
241            assertTrue(deleteRowByPrimaryKey(wrs, row, 1));
242        }
243
244        FileInputStream fis = new FileInputStream(MODFIED_DELETED_COFFEE_ROWS_XML);
245        try (WebRowSet wrs1 = rsf.createWebRowSet()) {
246            wrs1.readXml(fis);
247            // With setShowDeleted(false) which is the default,
248            // the deleted row should not be visible
249            for (int row : rowsToDelete) {
250                assertTrue(findRowByPrimaryKey(wrs1, row, 1));
251            }
252            assertTrue(wrs.size() == COFFEES_ROWS);
253            // With setShowDeleted(true), the deleted row should be visible
254            for (int row : rowsToDelete) {
255                assertTrue(findRowByPrimaryKey(wrs, row, 1));
256            }
257        }
258    }
259
260    /*
261     * Validate the expected Rows are contained within the RowSet
262     * that was populated by reading an xml file with all rows
263     * marked as a currentRow
264     */
265    @Test(dataProvider = "rowSetType")
266    public void WebRowSetTest0008(WebRowSet wrs1) throws Exception {
267        FileInputStream fis = new FileInputStream(COFFEE_ROWS_XML);
268        wrs1.readXml(fis);
269        assertTrue(wrs1.size() == COFFEES_ROWS);
270        assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS);
271        // Validate that the rows are not marked as deleted, inserted or updated
272        wrs1.beforeFirst();
273        while (wrs1.next()) {
274            assertFalse(wrs1.rowDeleted());
275            assertFalse(wrs1.rowInserted());
276            assertFalse(wrs1.rowUpdated());
277        }
278        wrs1.close();
279    }
280
281    /*
282     * Read an XML file to populate a WebRowSet and validate that the rows
283     * that are marked as deleted are marked as such in the WebRowSet
284     * Also validate that they are or are not visible based on the
285     * setShowDeleted value
286     */
287    @Test(dataProvider = "rowSetType")
288    public void WebRowSetTest0009(WebRowSet wrs1) throws Exception {
289        int[] rowsToDelete = {2, 4};
290        Object[] expectedRows = {1, 3, 5};
291        FileInputStream fis = new FileInputStream(DELETED_COFFEE_ROWS_XML);
292        wrs1.readXml(fis);
293        assertTrue(wrs1.size() == COFFEES_ROWS);
294        assertEquals(getPrimaryKeys(wrs1), expectedRows);
295        // With setShowDeleted(false) which is the default,
296        // the deleted row should not be visible
297        for (int row : rowsToDelete) {
298            assertFalse(findRowByPrimaryKey(wrs1, row, 1));
299        }
300        // With setShowDeleted(true), the deleted row should be visible
301        wrs1.setShowDeleted(true);
302        for (int row : rowsToDelete) {
303            assertTrue(findRowByPrimaryKey(wrs1, row, 1));
304        }
305        assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS);
306        wrs1.close();
307
308    }
309
310    /*
311     * Validate that the correct row in the WebRowSet that had been created
312     * from an xml file is marked as updated and contains the correct values
313     */
314    @Test(dataProvider = "rowSetType")
315    public void WebRowSetTest0010(WebRowSet wrs1) throws Exception {
316        FileInputStream fis = new FileInputStream(UPDATED_COFFEE_ROWS_XML);
317        wrs1.readXml(fis);
318        assertTrue(wrs1.size() == COFFEES_ROWS);
319        assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS);
320        wrs1.beforeFirst();
321        while (wrs1.next()) {
322            if (wrs1.getInt(1) == 3) {
323                assertTrue(wrs1.rowUpdated());
324                assertTrue(wrs1.getInt(5) == 21 && wrs1.getInt(6) == 69);
325                assertFalse(wrs1.rowDeleted());
326                assertFalse(wrs1.rowInserted());
327            } else {
328                assertFalse(wrs1.rowUpdated());
329                assertFalse(wrs1.rowDeleted());
330                assertFalse(wrs1.rowInserted());
331            }
332        }
333        wrs1.close();
334    }
335
336    /*
337     * Validate the correct row is marked as inserted in a WebRowSet
338     * that is read from an xml file
339     */
340    @Test(dataProvider = "rowSetType")
341    public void WebRowSetTest0011(WebRowSet wrs1) throws Exception {
342        int expectedSize = COFFEES_ROWS + 2;
343        int addedRowPK = 15;
344        int addedRowPK2 = 20;
345        Object[] expected = Arrays.copyOf(COFFEES_PRIMARY_KEYS, expectedSize);
346        expected[expectedSize - 2] = addedRowPK;
347        expected[expectedSize - 1] = addedRowPK2;
348        FileInputStream fis = new FileInputStream(INSERTED_COFFEE_ROWS_XML);
349        wrs1.readXml(fis);
350        assertTrue(wrs1.size() == expectedSize);
351        assertEqualsNoOrder(getPrimaryKeys(wrs1), expected);
352        wrs1.beforeFirst();
353        while (wrs1.next()) {
354            if (wrs1.getInt(1) == 15 || wrs1.getInt(1) == 20) {
355                assertTrue(wrs1.rowInserted());
356                assertFalse(wrs1.rowDeleted());
357                assertFalse(wrs1.rowUpdated());
358            } else {
359                assertFalse(wrs1.rowInserted());
360                assertFalse(wrs1.rowDeleted());
361                assertFalse(wrs1.rowUpdated());
362            }
363        }
364        wrs1.close();
365    }
366
367    /*
368     * Read an xml file which contains a row that was inserted and updated
369     */
370    @Test(dataProvider = "rowSetType")
371    public void WebRowSetTest0012(WebRowSet wrs1) throws Exception {
372        int expectedSize = COFFEES_ROWS + 1;
373        int addedRowPK = 100;
374        Object[] expected = Arrays.copyOf(COFFEES_PRIMARY_KEYS, expectedSize);
375        expected[expectedSize - 1] = addedRowPK;
376        FileInputStream fis = new FileInputStream(UPDATED_INSERTED_COFFEE_ROWS_XML);
377        wrs1.readXml(fis);
378        assertTrue(wrs1.size() == expectedSize);
379        assertEquals(getPrimaryKeys(wrs1), expected);
380        wrs1.beforeFirst();
381        while (wrs1.next()) {
382            if (wrs1.getInt(1) == addedRowPK) {
383                // Row that was inserted and updated
384                assertTrue(wrs1.rowUpdated());
385                assertTrue(
386                        wrs1.getBigDecimal(4).equals(BigDecimal.valueOf(12.99))
387                        && wrs1.getInt(6) == 125);
388                assertFalse(wrs1.rowDeleted());
389                assertTrue(wrs1.rowInserted());
390            } else {
391                // Remaining rows should only be inserted
392                assertFalse(wrs1.rowUpdated());
393                assertFalse(wrs1.rowDeleted());
394                assertTrue(wrs1.rowInserted());
395            }
396        }
397        wrs1.close();
398    }
399
400}
401