Mercurial > hg > monetdb-java

comparison tests/OnClientTester.java @ 575:08c9918177b2 onclient

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Do not check the updated row count, it varies between server versions
author Joeri van Ruth <joeri.van.ruth@monetdbsolutions.com>
date Wed, 06 Oct 2021 15:30:47 +0200 (2021-10-06)
parents 3370027aeb7f
children 687034945b3f
comparison
equal deleted inserted replaced
574:3370027aeb7f 575:08c9918177b2
156 156
157 public void test_Upload() throws SQLException, Failure { 157 public void test_Upload() throws SQLException, Failure {
158 prepare(); 158 prepare();
159 MyUploadHandler handler = new MyUploadHandler(100); 159 MyUploadHandler handler = new MyUploadHandler(100);
160 conn.setUploadHandler(handler); 160 conn.setUploadHandler(handler);
161 update("COPY INTO foo FROM 'banana' ON CLIENT", 100); 161 update("COPY INTO foo FROM 'banana' ON CLIENT");
162 assertEq("cancellation callback called", false, handler.isCancelled()); 162 assertEq("cancellation callback called", false, handler.isCancelled());
163 assertQueryInt("SELECT COUNT(*) FROM foo", 100); 163 assertQueryInt("SELECT COUNT(*) FROM foo", 100);
164 } 164 }
165 165
166 public void test_ClientRefusesUpload() throws SQLException, Failure { 166 public void test_ClientRefusesUpload() throws SQLException, Failure {
174 174
175 public void test_Offset0() throws SQLException, Failure { 175 public void test_Offset0() throws SQLException, Failure {
176 prepare(); 176 prepare();
177 MyUploadHandler handler = new MyUploadHandler(100); 177 MyUploadHandler handler = new MyUploadHandler(100);
178 conn.setUploadHandler(handler); 178 conn.setUploadHandler(handler);
179 update("COPY OFFSET 0 INTO foo FROM 'banana' ON CLIENT", 100); 179 update("COPY OFFSET 0 INTO foo FROM 'banana' ON CLIENT");
180 assertEq("cancellation callback called", false, handler.isCancelled()); 180 assertEq("cancellation callback called", false, handler.isCancelled());
181 assertQueryInt("SELECT MIN(i) FROM foo", 1); 181 assertQueryInt("SELECT MIN(i) FROM foo", 1);
182 assertQueryInt("SELECT MAX(i) FROM foo", 100); 182 assertQueryInt("SELECT MAX(i) FROM foo", 100);
183 } 183 }
184 184
185 public void test_Offset1() throws SQLException, Failure { 185 public void test_Offset1() throws SQLException, Failure {
186 prepare(); 186 prepare();
187 MyUploadHandler handler = new MyUploadHandler(100); 187 MyUploadHandler handler = new MyUploadHandler(100);
188 conn.setUploadHandler(handler); 188 conn.setUploadHandler(handler);
189 update("COPY OFFSET 1 INTO foo FROM 'banana' ON CLIENT", 100); 189 update("COPY OFFSET 1 INTO foo FROM 'banana' ON CLIENT");
190 assertEq("cancellation callback called", false, handler.isCancelled()); 190 assertEq("cancellation callback called", false, handler.isCancelled());
191 assertQueryInt("SELECT MIN(i) FROM foo", 1); 191 assertQueryInt("SELECT MIN(i) FROM foo", 1);
192 assertQueryInt("SELECT MAX(i) FROM foo", 100); 192 assertQueryInt("SELECT MAX(i) FROM foo", 100);
193 } 193 }
194 194
195 public void test_Offset5() throws SQLException, Failure { 195 public void test_Offset5() throws SQLException, Failure {
196 prepare(); 196 prepare();
197 MyUploadHandler handler = new MyUploadHandler(100); 197 MyUploadHandler handler = new MyUploadHandler(100);
198 conn.setUploadHandler(handler); 198 conn.setUploadHandler(handler);
199 update("COPY OFFSET 5 INTO foo FROM 'banana' ON CLIENT", 96); 199 update("COPY OFFSET 5 INTO foo FROM 'banana' ON CLIENT");
200 assertEq("cancellation callback called", false, handler.isCancelled()); 200 assertEq("cancellation callback called", false, handler.isCancelled());
201 assertQueryInt("SELECT MIN(i) FROM foo", 5); 201 assertQueryInt("SELECT MIN(i) FROM foo", 5);
202 assertQueryInt("SELECT MAX(i) FROM foo", 100); 202 assertQueryInt("SELECT MAX(i) FROM foo", 100);
203 } 203 }
204 204
205 public void test_ServerStopsReading() throws SQLException, Failure { 205 public void test_ServerStopsReading() throws SQLException, Failure {
206 prepare(); 206 prepare();
207 MyUploadHandler handler = new MyUploadHandler(100); 207 MyUploadHandler handler = new MyUploadHandler(100);
208 conn.setUploadHandler(handler); 208 conn.setUploadHandler(handler);
209 update("COPY 10 RECORDS INTO foo FROM 'banana' ON CLIENT", 10); 209 update("COPY 10 RECORDS INTO foo FROM 'banana' ON CLIENT");
210 assertEq("cancellation callback called", true, handler.isCancelled()); 210 assertEq("cancellation callback called", true, handler.isCancelled());
211 assertEq("handler encountered write error", true, handler.encounteredWriteError()); 211 assertEq("handler encountered write error", true, handler.encounteredWriteError());
212 // connection is still alive 212 // connection is still alive
213 assertQueryInt("SELECT COUNT(i) FROM foo", 10); 213 assertQueryInt("SELECT COUNT(i) FROM foo", 10);
214 } 214 }
216 public void test_Download(int n) throws SQLException, Failure { 216 public void test_Download(int n) throws SQLException, Failure {
217 prepare(); 217 prepare();
218 MyDownloadHandler handler = new MyDownloadHandler(); 218 MyDownloadHandler handler = new MyDownloadHandler();
219 conn.setDownloadHandler(handler); 219 conn.setDownloadHandler(handler);
220 String q = "INSERT INTO foo SELECT value as i, 'number' || value AS t FROM sys.generate_series(0, " + n + ")"; 220 String q = "INSERT INTO foo SELECT value as i, 'number' || value AS t FROM sys.generate_series(0, " + n + ")";
221 update(q, n); 221 update(q);
222 update("COPY (SELECT * FROM foo) INTO 'banana' ON CLIENT", -1); 222 update("COPY (SELECT * FROM foo) INTO 'banana' ON CLIENT");
223 assertEq("download attempts", 1, handler.countAttempts()); 223 assertEq("download attempts", 1, handler.countAttempts());
224 assertEq("lines downloaded", n, handler.lineCount()); 224 assertEq("lines downloaded", n, handler.lineCount());
225 // connection is still alive 225 // connection is still alive
226 assertQueryInt("SELECT COUNT(*) FROM foo", n); 226 assertQueryInt("SELECT COUNT(*) FROM foo", n);
227 } 227 }
233 public void test_ClientRefusesDownload() throws SQLException, Failure { 233 public void test_ClientRefusesDownload() throws SQLException, Failure {
234 prepare(); 234 prepare();
235 BugFixLevel level = getLevel(); 235 BugFixLevel level = getLevel();
236 MyDownloadHandler handler = new MyDownloadHandler("download refused"); 236 MyDownloadHandler handler = new MyDownloadHandler("download refused");
237 conn.setDownloadHandler(handler); 237 conn.setDownloadHandler(handler);
238 update("INSERT INTO foo SELECT value as i, 'number' || value AS t FROM sys.generate_series(0, 100)", 100); 238 update("INSERT INTO foo SELECT value as i, 'number' || value AS t FROM sys.generate_series(0, 100)");
239 expectError("COPY (SELECT * FROM foo) INTO 'banana' ON CLIENT", "download refused"); 239 expectError("COPY (SELECT * FROM foo) INTO 'banana' ON CLIENT", "download refused");
240 // Wish it were different but the server closes the connection 240 // Wish it were different but the server closes the connection
241 expectError("SELECT 42 -- check if the connection still works", "Connection to server lost!"); 241 expectError("SELECT 42 -- check if the connection still works", "Connection to server lost!");
242 if (level.compareTo(BugFixLevel.CanRefuseDownload) >= 0) { 242 if (level.compareTo(BugFixLevel.CanRefuseDownload) >= 0) {
243 // connection is still alive 243 // connection is still alive
250 prepare(); 250 prepare();
251 int n = 4_000_000; 251 int n = 4_000_000;
252 MyUploadHandler handler = new MyUploadHandler(n); 252 MyUploadHandler handler = new MyUploadHandler(n);
253 conn.setUploadHandler(handler); 253 conn.setUploadHandler(handler);
254 handler.setChunkSize(1024 * 1024); 254 handler.setChunkSize(1024 * 1024);
255 update("COPY INTO foo FROM 'banana' ON CLIENT", n); 255 update("COPY INTO foo FROM 'banana' ON CLIENT");
256 assertEq("cancellation callback called", false, handler.isCancelled()); 256 assertEq("cancellation callback called", false, handler.isCancelled());
257 // connection is still alive 257 // connection is still alive
258 assertQueryInt("SELECT COUNT(DISTINCT i) FROM foo", n); 258 assertQueryInt("SELECT COUNT(DISTINCT i) FROM foo", n);
259 } 259 }
260 260
274 ByteArrayInputStream s = new ByteArrayInputStream(data.getBytes(StandardCharsets.UTF_8)); 274 ByteArrayInputStream s = new ByteArrayInputStream(data.getBytes(StandardCharsets.UTF_8));
275 handle.uploadFrom(s); 275 handle.uploadFrom(s);
276 } 276 }
277 }; 277 };
278 conn.setUploadHandler(handler); 278 conn.setUploadHandler(handler);
279 update("COPY INTO foo FROM 'banana' ON CLIENT", 3); 279 update("COPY INTO foo FROM 'banana' ON CLIENT");
280 // connection is still alive 280 // connection is still alive
281 assertQueryInt("SELECT i FROM foo WHERE t = 'three'", 3); 281 assertQueryInt("SELECT i FROM foo WHERE t = 'three'", 3);
282 } 282 }
283 283
284 public void test_UploadFromReader() throws SQLException, Failure { 284 public void test_UploadFromReader() throws SQLException, Failure {
292 StringReader r = new StringReader(data); 292 StringReader r = new StringReader(data);
293 handle.uploadFrom(r); 293 handle.uploadFrom(r);
294 } 294 }
295 }; 295 };
296 conn.setUploadHandler(handler); 296 conn.setUploadHandler(handler);
297 update("COPY INTO foo FROM 'banana' ON CLIENT", 3); 297 update("COPY INTO foo FROM 'banana' ON CLIENT");
298 assertQueryInt("SELECT i FROM foo WHERE t = 'three'", 3); 298 assertQueryInt("SELECT i FROM foo WHERE t = 'three'", 3);
299 } 299 }
300 300
301 public void test_UploadFromReaderOffset() throws SQLException, Failure { 301 public void test_UploadFromReaderOffset() throws SQLException, Failure {
302 prepare(); 302 prepare();
308 BufferedReader r = new BufferedReader(new StringReader(data)); 308 BufferedReader r = new BufferedReader(new StringReader(data));
309 handle.uploadFrom(r, linesToSkip); 309 handle.uploadFrom(r, linesToSkip);
310 } 310 }
311 }; 311 };
312 conn.setUploadHandler(handler); 312 conn.setUploadHandler(handler);
313 update("COPY OFFSET 2 INTO foo FROM 'banana' ON CLIENT", 2); 313 update("COPY OFFSET 2 INTO foo FROM 'banana' ON CLIENT");
314 assertQueryInt("SELECT i FROM foo WHERE t = 'three'", 3); 314 assertQueryInt("SELECT i FROM foo WHERE t = 'three'", 3);
315 } 315 }
316 316
317 public void test_FailUploadLate() throws SQLException, Failure { 317 public void test_FailUploadLate() throws SQLException, Failure {
318 prepare(); 318 prepare();
347 347
348 public void test_FailDownloadLate() throws SQLException, Failure { 348 public void test_FailDownloadLate() throws SQLException, Failure {
349 prepare(); 349 prepare();
350 MyDownloadHandler handler = new MyDownloadHandler(200, "download refused"); 350 MyDownloadHandler handler = new MyDownloadHandler(200, "download refused");
351 conn.setDownloadHandler(handler); 351 conn.setDownloadHandler(handler);
352 update("INSERT INTO foo SELECT value as i, 'number' || value AS t FROM sys.generate_series(0, 100)", 100); 352 update("INSERT INTO foo SELECT value as i, 'number' || value AS t FROM sys.generate_series(0, 100)");
353 expectError("COPY (SELECT * FROM sys.generate_series(0,200)) INTO 'banana' ON CLIENT", "download refused"); 353 expectError("COPY (SELECT * FROM sys.generate_series(0,200)) INTO 'banana' ON CLIENT", "download refused");
354 // Exception closes the connection 354 // Exception closes the connection
355 assertEq("connection is closed", conn.isClosed(), true); 355 assertEq("connection is closed", conn.isClosed(), true);
356 } 356 }
357 357
364 ps.println("1|one"); 364 ps.println("1|one");
365 ps.println("2|two"); 365 ps.println("2|two");
366 ps.println("3|three"); 366 ps.println("3|three");
367 ps.close(); 367 ps.close();
368 conn.setUploadHandler(new FileTransferHandler(d, true)); 368 conn.setUploadHandler(new FileTransferHandler(d, true));
369 update("COPY INTO foo FROM 'data.txt' ON CLIENT", 3); 369 update("COPY INTO foo FROM 'data.txt' ON CLIENT");
370 assertQueryInt("SELECT SUM(i) FROM foo", 6); 370 assertQueryInt("SELECT SUM(i) FROM foo", 6);
371 } 371 }
372 372
373 public void test_FileTransferHandlerUploadRefused() throws IOException, SQLException, Failure { 373 public void test_FileTransferHandlerUploadRefused() throws IOException, SQLException, Failure {
374 prepare(); 374 prepare();
389 assertQueryInt("SELECT SUM(i) FROM foo", 0); 389 assertQueryInt("SELECT SUM(i) FROM foo", 0);
390 } 390 }
391 391
392 public void test_FileTransferHandlerDownload() throws SQLException, Failure, IOException { 392 public void test_FileTransferHandlerDownload() throws SQLException, Failure, IOException {
393 prepare(); 393 prepare();
394 update("INSERT INTO foo VALUES (42, 'forty-two')", 1); 394 update("INSERT INTO foo VALUES (42, 'forty-two')");
395 Path d = getTmpDir(currentTestName); 395 Path d = getTmpDir(currentTestName);
396 conn.setDownloadHandler(new FileTransferHandler(d, false)); 396 conn.setDownloadHandler(new FileTransferHandler(d, false));
397 update("COPY SELECT * FROM foo INTO 'data.txt' ON CLIENT", -1); 397 update("COPY SELECT * FROM foo INTO 'data.txt' ON CLIENT");
398 List<String> lines = Files.readAllLines(d.resolve("data.txt")); 398 List<String> lines = Files.readAllLines(d.resolve("data.txt"));
399 assertEq("lines written", lines.size(), 1); 399 assertEq("lines written", lines.size(), 1);
400 assertEq("line content", lines.get(0), "42|\"forty-two\""); 400 assertEq("line content", lines.get(0), "42|\"forty-two\"");
401 // connection is still alive 401 // connection is still alive
402 assertQueryInt("SELECT SUM(i) FROM foo", 42); 402 assertQueryInt("SELECT SUM(i) FROM foo", 42);
403 } 403 }
404 404
405 public void test_FileTransferHandlerDownloadRefused() throws SQLException, Failure, IOException { 405 public void test_FileTransferHandlerDownloadRefused() throws SQLException, Failure, IOException {
406 prepare(); 406 prepare();
407 BugFixLevel level = getLevel(); 407 BugFixLevel level = getLevel();
408 update("INSERT INTO foo VALUES (42, 'forty-two')", 1); 408 update("INSERT INTO foo VALUES (42, 'forty-two')");
409 Path d = getTmpDir(currentTestName); 409 Path d = getTmpDir(currentTestName);
410 Path d2 = getTmpDir(currentTestName + "2"); 410 Path d2 = getTmpDir(currentTestName + "2");
411 conn.setDownloadHandler(new FileTransferHandler(d2, false)); 411 conn.setDownloadHandler(new FileTransferHandler(d2, false));
412 String quoted = d.resolve("data.txt").toAbsolutePath().toString().replaceAll("'", "''"); 412 String quoted = d.resolve("data.txt").toAbsolutePath().toString().replaceAll("'", "''");
413 expectError("COPY SELECT * FROM foo INTO R'" + quoted + "' ON CLIENT", "not in download directory"); 413 expectError("COPY SELECT * FROM foo INTO R'" + quoted + "' ON CLIENT", "not in download directory");