| /* |
| * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package test.rowset.webrowset; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileReader; |
| import java.io.InputStreamReader; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.io.OutputStreamWriter; |
| import java.math.BigDecimal; |
| import java.sql.ResultSet; |
| import java.util.Arrays; |
| import javax.sql.rowset.WebRowSet; |
| import static org.testng.Assert.assertEquals; |
| import static org.testng.Assert.assertEqualsNoOrder; |
| import static org.testng.Assert.assertFalse; |
| import static org.testng.Assert.assertTrue; |
| import org.testng.annotations.Test; |
| import test.rowset.cachedrowset.CommonCachedRowSetTests; |
| |
| public abstract class CommonWebRowSetTests extends CommonCachedRowSetTests { |
| |
| protected final String XMLFILEPATH = System.getProperty("test.src", ".") |
| + File.separatorChar + "xml" + File.separatorChar; |
| protected final String COFFEE_ROWS_XML = XMLFILEPATH + "COFFEE_ROWS.xml"; |
| protected final String DELETED_COFFEE_ROWS_XML |
| = XMLFILEPATH + "DELETED_COFFEE_ROWS.xml"; |
| protected final String MODFIED_DELETED_COFFEE_ROWS_XML |
| = XMLFILEPATH + "MODFIED_DELETED_COFFEE_ROWS.xml"; |
| protected final String UPDATED_COFFEE_ROWS_XML |
| = XMLFILEPATH + "UPDATED_COFFEE_ROWS.xml"; |
| protected final String INSERTED_COFFEE_ROWS_XML |
| = XMLFILEPATH + "INSERTED_COFFEE_ROWS.xml"; |
| protected final String UPDATED_INSERTED_COFFEE_ROWS_XML |
| = XMLFILEPATH + "UPDATED_INSERTED_COFFEE_ROWS.xml"; |
| |
| |
| /* |
| * Utility method to write a WebRowSet XML file via an OutputStream |
| */ |
| protected ByteArrayOutputStream writeWebRowSetWithOutputStream(WebRowSet rs) throws Exception { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| try (ObjectOutputStream oos = new ObjectOutputStream(baos)) { |
| rs.writeXml(oos); |
| } |
| return baos; |
| } |
| |
| /* |
| * Utility method to write a WebRowSet XML file via an OutputStream |
| * and populating the WebRowSet via a ResultSet |
| */ |
| protected ByteArrayOutputStream writeWebRowSetWithOutputStream(ResultSet rs) throws Exception { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| try (ObjectOutputStream oos = new ObjectOutputStream(baos)) { |
| WebRowSet wrs = rsf.createWebRowSet(); |
| wrs.writeXml(rs, oos); |
| } |
| return baos; |
| } |
| |
| |
| /* |
| * Utility method to popoulate a WebRowSet via a InputStream |
| */ |
| protected WebRowSet readWebRowSetWithOInputStream(ByteArrayOutputStream baos) throws Exception { |
| WebRowSet wrs1 = rsf.createWebRowSet(); |
| try (ObjectInputStream ois |
| = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()))) { |
| wrs1.readXml(ois); |
| } |
| return wrs1; |
| } |
| |
| /* |
| * Utility method to write a WebRowSet XML file via an Writer |
| */ |
| protected ByteArrayOutputStream writeWebRowSetWithOutputStreamWithWriter(WebRowSet rs) throws Exception { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| OutputStreamWriter osw = new OutputStreamWriter(baos); |
| rs.writeXml(osw); |
| return baos; |
| } |
| |
| /* |
| * Utility method to write a WebRowSet XML file via an Writer and populating |
| * the WebRowSet via a ResultSet |
| */ |
| protected ByteArrayOutputStream writeWebRowSetWithOutputStreamWithWriter(ResultSet rs) throws Exception { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| OutputStreamWriter osw = new OutputStreamWriter(baos); |
| WebRowSet wrs = rsf.createWebRowSet(); |
| wrs.writeXml(rs, osw); |
| return baos; |
| } |
| |
| /* |
| * Utility method to popoulate a WebRowSet via a Readar |
| */ |
| protected WebRowSet readWebRowSetWithOInputStreamWithReader(ByteArrayOutputStream baos) throws Exception { |
| WebRowSet wrs1 = rsf.createWebRowSet(); |
| InputStreamReader isr = new InputStreamReader(new ByteArrayInputStream(baos.toByteArray())); |
| wrs1.readXml(isr); |
| return wrs1; |
| } |
| |
| /* |
| * Validate the expected Rows are contained within the RowSet |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees") |
| public void WebRowSetTest0000(WebRowSet wrs) throws Exception { |
| assertEquals(getPrimaryKeys(wrs), COFFEES_PRIMARY_KEYS); |
| assertEquals(wrs.size(), COFFEES_ROWS); |
| wrs.close(); |
| } |
| |
| /* |
| * Validate the expected Rows are contained within the RowSet |
| * populated by readXML(Reader) |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void WebRowSetTest0001(WebRowSet wrs1) throws Exception { |
| |
| try (FileReader fr = new FileReader(COFFEE_ROWS_XML)) { |
| wrs1.readXml(fr); |
| } |
| assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS); |
| assertEquals(wrs1.size(), COFFEES_ROWS); |
| wrs1.close(); |
| |
| } |
| |
| /* |
| * Validate the expected Rows are contained within the RowSet |
| * populated by readXML(InputStream) |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void WebRowSetTest0002(WebRowSet wrs1) throws Exception { |
| try (FileInputStream fis = new FileInputStream(COFFEE_ROWS_XML)) { |
| wrs1.readXml(fis); |
| } |
| assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS); |
| assertEquals(wrs1.size(), COFFEES_ROWS); |
| wrs1.close(); |
| } |
| |
| /* |
| * Write a WebRowSet via writeXML(OutputStream), read it |
| * back via readXML(InputStream) and validate the primary keys |
| * are the same |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees") |
| public void WebRowSetTest0003(WebRowSet wrs) throws Exception { |
| ByteArrayOutputStream baos = writeWebRowSetWithOutputStream(wrs); |
| try (WebRowSet wrs1 = readWebRowSetWithOInputStream(baos)) { |
| assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS); |
| assertEquals(wrs1.size(), COFFEES_ROWS); |
| } |
| } |
| |
| /* |
| * Write a ResultSet via writeXML(OutputStream), read it |
| * back via readXML(InputStream) and validate the primary keys |
| * are the same |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees") |
| public void WebRowSetTest0004(WebRowSet wrs) throws Exception { |
| ResultSet rs = wrs; |
| rs.beforeFirst(); |
| ByteArrayOutputStream baos = writeWebRowSetWithOutputStream(rs); |
| try (WebRowSet wrs1 = readWebRowSetWithOInputStream(baos)) { |
| assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS); |
| assertEquals(wrs1.size(), COFFEES_ROWS); |
| } |
| } |
| |
| /* |
| * Write a WebRowSet via writeXML(Writer), read it |
| * back via readXML(Reader) and validate the primary keys |
| * are the same |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees") |
| public void WebRowSetTest0005(WebRowSet wrs) throws Exception { |
| ByteArrayOutputStream baos = writeWebRowSetWithOutputStreamWithWriter(wrs); |
| try (WebRowSet wrs1 = readWebRowSetWithOInputStreamWithReader(baos)) { |
| assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS); |
| assertEquals(wrs1.size(), COFFEES_ROWS); |
| } |
| } |
| |
| /* |
| * Write a WebRowSet via writeXML(Writer), read it |
| * back via readXML(Reader) and validate the primary keys |
| * are the same |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees") |
| public void WebRowSetTest0006(WebRowSet wrs) throws Exception { |
| ResultSet rs = wrs; |
| rs.beforeFirst(); |
| ByteArrayOutputStream baos = writeWebRowSetWithOutputStreamWithWriter(rs); |
| try (WebRowSet wrs1 = readWebRowSetWithOInputStreamWithReader(baos)) { |
| assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS); |
| assertEquals(wrs1.size(), COFFEES_ROWS); |
| } |
| } |
| |
| /* |
| * Validate the expected Rows are contained within the RowSet |
| * after deleting the specified rows |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees", enabled = false) |
| public void WebRowSetTest0007(WebRowSet wrs) throws Exception { |
| assertEquals(getPrimaryKeys(wrs), COFFEES_PRIMARY_KEYS); |
| int[] rowsToDelete = {2, 4}; |
| assertEquals(getPrimaryKeys(wrs), COFFEES_PRIMARY_KEYS); |
| for (int row : rowsToDelete) { |
| assertTrue(deleteRowByPrimaryKey(wrs, row, 1)); |
| } |
| |
| FileInputStream fis = new FileInputStream(MODFIED_DELETED_COFFEE_ROWS_XML); |
| try (WebRowSet wrs1 = rsf.createWebRowSet()) { |
| wrs1.readXml(fis); |
| // With setShowDeleted(false) which is the default, |
| // the deleted row should not be visible |
| for (int row : rowsToDelete) { |
| assertTrue(findRowByPrimaryKey(wrs1, row, 1)); |
| } |
| assertTrue(wrs.size() == COFFEES_ROWS); |
| // With setShowDeleted(true), the deleted row should be visible |
| for (int row : rowsToDelete) { |
| assertTrue(findRowByPrimaryKey(wrs, row, 1)); |
| } |
| } |
| } |
| |
| /* |
| * Validate the expected Rows are contained within the RowSet |
| * that was populated by reading an xml file with all rows |
| * marked as a currentRow |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void WebRowSetTest0008(WebRowSet wrs1) throws Exception { |
| FileInputStream fis = new FileInputStream(COFFEE_ROWS_XML); |
| wrs1.readXml(fis); |
| assertTrue(wrs1.size() == COFFEES_ROWS); |
| assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS); |
| // Validate that the rows are not marked as deleted, inserted or updated |
| wrs1.beforeFirst(); |
| while (wrs1.next()) { |
| assertFalse(wrs1.rowDeleted()); |
| assertFalse(wrs1.rowInserted()); |
| assertFalse(wrs1.rowUpdated()); |
| } |
| wrs1.close(); |
| } |
| |
| /* |
| * Read an XML file to populate a WebRowSet and validate that the rows |
| * that are marked as deleted are marked as such in the WebRowSet |
| * Also validate that they are or are not visible based on the |
| * setShowDeleted value |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void WebRowSetTest0009(WebRowSet wrs1) throws Exception { |
| int[] rowsToDelete = {2, 4}; |
| Object[] expectedRows = {1, 3, 5}; |
| FileInputStream fis = new FileInputStream(DELETED_COFFEE_ROWS_XML); |
| wrs1.readXml(fis); |
| assertTrue(wrs1.size() == COFFEES_ROWS); |
| assertEquals(getPrimaryKeys(wrs1), expectedRows); |
| // With setShowDeleted(false) which is the default, |
| // the deleted row should not be visible |
| for (int row : rowsToDelete) { |
| assertFalse(findRowByPrimaryKey(wrs1, row, 1)); |
| } |
| // With setShowDeleted(true), the deleted row should be visible |
| wrs1.setShowDeleted(true); |
| for (int row : rowsToDelete) { |
| assertTrue(findRowByPrimaryKey(wrs1, row, 1)); |
| } |
| assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS); |
| wrs1.close(); |
| |
| } |
| |
| /* |
| * Validate that the correct row in the WebRowSet that had been created |
| * from an xml file is marked as updated and contains the correct values |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void WebRowSetTest0010(WebRowSet wrs1) throws Exception { |
| FileInputStream fis = new FileInputStream(UPDATED_COFFEE_ROWS_XML); |
| wrs1.readXml(fis); |
| assertTrue(wrs1.size() == COFFEES_ROWS); |
| assertEquals(getPrimaryKeys(wrs1), COFFEES_PRIMARY_KEYS); |
| wrs1.beforeFirst(); |
| while (wrs1.next()) { |
| if (wrs1.getInt(1) == 3) { |
| assertTrue(wrs1.rowUpdated()); |
| assertTrue(wrs1.getInt(5) == 21 && wrs1.getInt(6) == 69); |
| assertFalse(wrs1.rowDeleted()); |
| assertFalse(wrs1.rowInserted()); |
| } else { |
| assertFalse(wrs1.rowUpdated()); |
| assertFalse(wrs1.rowDeleted()); |
| assertFalse(wrs1.rowInserted()); |
| } |
| } |
| wrs1.close(); |
| } |
| |
| /* |
| * Validate the correct row is marked as inserted in a WebRowSet |
| * that is read from an xml file |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void WebRowSetTest0011(WebRowSet wrs1) throws Exception { |
| int expectedSize = COFFEES_ROWS + 2; |
| int addedRowPK = 15; |
| int addedRowPK2 = 20; |
| Object[] expected = Arrays.copyOf(COFFEES_PRIMARY_KEYS, expectedSize); |
| expected[expectedSize - 2] = addedRowPK; |
| expected[expectedSize - 1] = addedRowPK2; |
| FileInputStream fis = new FileInputStream(INSERTED_COFFEE_ROWS_XML); |
| wrs1.readXml(fis); |
| assertTrue(wrs1.size() == expectedSize); |
| assertEqualsNoOrder(getPrimaryKeys(wrs1), expected); |
| wrs1.beforeFirst(); |
| while (wrs1.next()) { |
| if (wrs1.getInt(1) == 15 || wrs1.getInt(1) == 20) { |
| assertTrue(wrs1.rowInserted()); |
| assertFalse(wrs1.rowDeleted()); |
| assertFalse(wrs1.rowUpdated()); |
| } else { |
| assertFalse(wrs1.rowInserted()); |
| assertFalse(wrs1.rowDeleted()); |
| assertFalse(wrs1.rowUpdated()); |
| } |
| } |
| wrs1.close(); |
| } |
| |
| /* |
| * Read an xml file which contains a row that was inserted and updated |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void WebRowSetTest0012(WebRowSet wrs1) throws Exception { |
| int expectedSize = COFFEES_ROWS + 1; |
| int addedRowPK = 100; |
| Object[] expected = Arrays.copyOf(COFFEES_PRIMARY_KEYS, expectedSize); |
| expected[expectedSize - 1] = addedRowPK; |
| FileInputStream fis = new FileInputStream(UPDATED_INSERTED_COFFEE_ROWS_XML); |
| wrs1.readXml(fis); |
| assertTrue(wrs1.size() == expectedSize); |
| assertEquals(getPrimaryKeys(wrs1), expected); |
| wrs1.beforeFirst(); |
| while (wrs1.next()) { |
| if (wrs1.getInt(1) == addedRowPK) { |
| // Row that was inserted and updated |
| assertTrue(wrs1.rowUpdated()); |
| assertTrue( |
| wrs1.getBigDecimal(4).equals(BigDecimal.valueOf(12.99)) |
| && wrs1.getInt(6) == 125); |
| assertFalse(wrs1.rowDeleted()); |
| assertTrue(wrs1.rowInserted()); |
| } else { |
| // Remaining rows should only be inserted |
| assertFalse(wrs1.rowUpdated()); |
| assertFalse(wrs1.rowDeleted()); |
| assertTrue(wrs1.rowInserted()); |
| } |
| } |
| wrs1.close(); |
| } |
| |
| } |
