1/* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index' 16import ddm from '@ohos.data.distributedData'; 17 18describe('queryTest', function() { 19 20 /** 21 * @tc.name QueryResetTest001 22 * @tc.desc Test Js Api Query.Reset() testcase 001 23 * @tc.type: FUNC 24 * @tc.require: issueNumber 25 */ 26 it('QueryResetTest001', 0, async function(done) { 27 var query = null; 28 try { 29 query = new ddm.Query(); 30 expect("").assertEqual(query.getSqlLike()); 31 query.equalTo("test", 3); 32 console.info("query is " + query.getSqlLike()); 33 expect(query.getSqlLike() !== "").assertTrue(); 34 query.reset(); 35 expect("").assertEqual(query.getSqlLike()); 36 console.info("query is " + query.getSqlLike()); 37 } catch (e) { 38 console.error("simply calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 39 expect(null).assertFail(); 40 } 41 query = null; 42 done(); 43 }) 44 45 /** 46 * @tc.name QueryResetTest002 47 * @tc.desc Test Js Api Query.Reset() testcase 002 48 * @tc.type: FUNC 49 * @tc.require: issueNumber 50 */ 51 it('QueryResetTest002', 0, async function(done) { 52 var query = null; 53 try { 54 query = new ddm.Query(); 55 expect("").assertEqual(query.getSqlLike()); 56 query.equalTo("number", 5); 57 query.equalTo("string", 'v'); 58 query.equalTo("boolean", false); 59 console.info("query is " + query.getSqlLike()); 60 expect(query.getSqlLike() !== "").assertTrue(); 61 query.reset(); 62 query.reset(); 63 query.reset(); 64 expect("").assertEqual(query.getSqlLike()); 65 console.info("sql after reset: " + query.getSqlLike()); 66 console.info("query is " + query.getSqlLike()); 67 } catch (e) { 68 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 69 expect(null).assertFail(); 70 } 71 query = null; 72 done(); 73 }) 74 75 /** 76 * @tc.name QueryResetTest003 77 * @tc.desc Test Js Api Query.Reset() testcase 003 78 * @tc.type: FUNC 79 * @tc.require: issueNumber 80 */ 81 it('QueryResetTest003', 0, async function(done) { 82 var query = null; 83 try { 84 query = new ddm.Query(); 85 expect("").assertEqual(query.getSqlLike()); 86 query.equalTo("key", "value"); 87 expect(query.getSqlLike() !== "").assertTrue(); 88 let sql = query.getSqlLike(); 89 query.reset().equalTo("key", "value"); 90 console.info("query is " + query.getSqlLike()); 91 expect(sql === query.getSqlLike()).assertTrue(); 92 } catch (e) { 93 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 94 expect(null).assertFail(); 95 } 96 query = null; 97 done(); 98 }) 99 100 /** 101 * @tc.name QueryResetTest004 102 * @tc.desc Test Js Api Query.Reset() testcase 004 103 * @tc.type: FUNC 104 * @tc.require: issueNumber 105 */ 106 it('QueryResetTest004', 0, async function(done) { 107 var query = null; 108 try { 109 query = new ddm.Query(); 110 expect("").assertEqual(query.getSqlLike()); 111 query.equalTo("key", "value"); 112 expect(query.getSqlLike() !== "").assertTrue(); 113 query.reset(3); 114 console.info("should throw exception on invalid arguments"); 115 expect(null).assertFail(); 116 } catch (e) { 117 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 118 } 119 query = null; 120 done(); 121 }) 122 123 /** 124 * @tc.name QueryEqaulToTest001 125 * @tc.desc Test Js Api Query.EqaulTo() testcase 001 126 * @tc.type: FUNC 127 * @tc.require: issueNumber 128 */ 129 it('QueryEqaulToTest001', 0, async function(done) { 130 var query = null; 131 try { 132 query = new ddm.Query(); 133 expect("").assertEqual(query.getSqlLike()); 134 query.equalTo("key1", 5); 135 query.equalTo("key2", 5.0); 136 query.equalTo("key3", false); 137 query.equalTo("key3", "string"); 138 expect(query.getSqlLike() !== "").assertTrue(); 139 console.info("query is " + query.getSqlLike()); 140 } catch (e) { 141 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 142 expect(null).assertFail(); 143 } 144 query = null; 145 done(); 146 }) 147 148 /** 149 * @tc.name QueryEqualToTest002 150 * @tc.desc Test Js Api Query.EqualTo() testcase 002 151 * @tc.type: FUNC 152 * @tc.require: issueNumber 153 */ 154 it('QueryEqualToTest002', 0, async function(done) { 155 var query = null; 156 try { 157 query = new ddm.Query(); 158 expect("").assertEqual(query.getSqlLike()); 159 query.equalTo("key1", 1).equalTo("key2", 2).equalTo("key3", 3); 160 expect(query.getSqlLike() !== "").assertTrue(); 161 console.info("query is " + query.getSqlLike()); 162 } catch (e) { 163 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 164 expect(null).assertFail(); 165 } 166 query = null; 167 done(); 168 }) 169 170 /** 171 * @tc.name QueryEqualToTest003 172 * @tc.desc Test Js Api Query.EqualTo() testcase 003 173 * @tc.type: FUNC 174 * @tc.require: issueNumber 175 */ 176 it('QueryEqualToTest003', 0, async function(done) { 177 var query = null; 178 try { 179 query = new ddm.Query(); 180 expect("").assertEqual(query.getSqlLike()); 181 query.equalTo("key2", NaN); 182 expect(query.getSqlLike() !== "").assertTrue(); 183 console.info("query is " + query.getSqlLike()); 184 } catch (e) { 185 expect(null).assertFail(); 186 } 187 query = null; 188 done(); 189 }) 190 191 /** 192 * @tc.name QueryEqualToTest004 193 * @tc.desc Test Js Api Query.EqualTo() testcase 004 194 * @tc.type: FUNC 195 * @tc.require: issueNumber 196 */ 197 it('QueryEqualToTest004', 0, async function(done) { 198 var query = null; 199 try { 200 query = new ddm.Query(); 201 expect("").assertEqual(query.getSqlLike()); 202 query.equalTo("key1", "value", "too more"); 203 console.info("should throw exception on invalid arguments"); 204 console.info("query is " + query.getSqlLike()); 205 expect(null).assertFail(); 206 } catch (e) { 207 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 208 } 209 query = null; 210 done(); 211 }) 212 213 /** 214 * @tc.name QueryNotEqualToTest001 215 * @tc.desc Test Js Api Query.NotEqualTo() testcase 001 216 * @tc.type: FUNC 217 * @tc.require: issueNumber 218 */ 219 it('QueryNotEqualToTest001', 0, async function(done) { 220 var query = null; 221 try { 222 query = new ddm.Query(); 223 expect("").assertEqual(query.getSqlLike()); 224 query.notEqualTo("key1", 5); 225 query.notEqualTo("key2", 5.0); 226 query.notEqualTo("key3", false); 227 query.notEqualTo("key4", "string"); 228 expect(query.getSqlLike() !== "").assertTrue(); 229 console.info("query is " + query.getSqlLike()); 230 } catch (e) { 231 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 232 expect(null).assertFail(); 233 } 234 query = null; 235 done(); 236 }) 237 238 /** 239 * @tc.name QueryNotEqualToTest002 240 * @tc.desc Test Js Api Query.NotEqualTo() testcase 002 241 * @tc.type: FUNC 242 * @tc.require: issueNumber 243 */ 244 it('QueryNotEqualToTest002', 0, async function(done) { 245 var query = null; 246 try { 247 query = new ddm.Query(); 248 expect("").assertEqual(query.getSqlLike()); 249 query.notEqualTo("key", 5); 250 query.reset(); 251 query.notEqualTo("key0", 5).equalTo("key1", 5).notEqualTo("key2", "str").notEqualTo("key3", false); 252 expect(query.getSqlLike() !== "").assertTrue(); 253 console.info("query is " + query.getSqlLike()); 254 } catch (e) { 255 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 256 expect(null).assertFail(); 257 } 258 query = null; 259 done(); 260 }) 261 262 /** 263 * @tc.name QueryNotEqualToTest003 264 * @tc.desc Test Js Api Query.NotEqualTo() testcase 003 265 * @tc.type: FUNC 266 * @tc.require: issueNumber 267 */ 268 it('QueryNotEqualToTest003', 0, async function(done) { 269 var query = null; 270 try { 271 query = new ddm.Query(); 272 expect("").assertEqual(query.getSqlLike()); 273 query.notEqualTo("key2", NaN); 274 expect(query.getSqlLike() !== "").assertTrue(); 275 console.info("query is " + query.getSqlLike()); 276 } catch (e) { 277 expect(null).assertFail(); 278 } 279 query = null; 280 done(); 281 }) 282 283 /** 284 * @tc.name QueryNotEqualToTest004 285 * @tc.desc Test Js Api Query.NotEqualTo() testcase 004 286 * @tc.type: FUNC 287 * @tc.require: issueNumber 288 */ 289 it('QueryNotEqualToTest004', 0, async function(done) { 290 var query = null; 291 try { 292 query = new ddm.Query(); 293 expect("").assertEqual(query.getSqlLike()); 294 query.notEqualTo("key1", "value", "too more", 4); 295 console.info("should throw exception on invalid arguments"); 296 } catch (e) { 297 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 298 } 299 query = null; 300 done(); 301 }) 302 303 /** 304 * @tc.name QueryGreaterThanTest001 305 * @tc.desc Test Js Api Query.GreaterThan() testcase 001 306 * @tc.type: FUNC 307 * @tc.require: issueNumber 308 */ 309 it('QueryGreaterThanTest001', 0, async function(done) { 310 var query = null; 311 try { 312 query = new ddm.Query(); 313 expect("").assertEqual(query.getSqlLike()); 314 query.greaterThan("key1", 5); 315 query.greaterThan("key2", 5.0); 316 query.greaterThan("key3", true); 317 query.greaterThan("key4", "string"); 318 expect(query.getSqlLike() !== "").assertTrue(); 319 console.info("query is " + query.getSqlLike()); 320 } catch (e) { 321 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 322 expect(null).assertFail(); 323 } 324 query = null; 325 done(); 326 }) 327 328 /** 329 * @tc.name QueryGreatThanTest002 330 * @tc.desc Test Js Api Query.GreatThan() testcase 002 331 * @tc.type: FUNC 332 * @tc.require: issueNumber 333 */ 334 it('QueryGreatThanTest002', 0, async function(done) { 335 var query = null; 336 try { 337 query = new ddm.Query(); 338 expect("").assertEqual(query.getSqlLike()); 339 query.greaterThan("key", 5); 340 query.reset(); 341 query.greaterThan("key0", 5).greaterThan("key1", "v5").greaterThan("key3", false); 342 expect(query.getSqlLike() !== "").assertTrue(); 343 console.info("query is " + query.getSqlLike()); 344 } catch (e) { 345 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 346 expect(null).assertFail(); 347 } 348 query = null; 349 done(); 350 }) 351 352 /** 353 * @tc.name QueryGreatThanTest003 354 * @tc.desc Test Js Api Query.GreatThan() testcase 003 355 * @tc.type: FUNC 356 * @tc.require: issueNumber 357 */ 358 it('QueryGreatThanTest003', 0, async function(done) { 359 var query = null; 360 try { 361 query = new ddm.Query(); 362 expect("").assertEqual(query.getSqlLike()); 363 query.greaterThan("key2", NaN); 364 console.info("should throw exception on invalid arguments"); 365 console.info("query is " + query.getSqlLike()); 366 } catch (e) { 367 expect(null).assertFail(); 368 } 369 query = null; 370 done(); 371 }) 372 373 /** 374 * @tc.name QueryGreatThanTest004 375 * @tc.desc Test Js Api Query.GreatThan() testcase 004 376 * @tc.type: FUNC 377 * @tc.require: issueNumber 378 */ 379 it('QueryGreatThanTest004', 0, async function(done) { 380 var query = null; 381 try { 382 query = new ddm.Query(); 383 expect("").assertEqual(query.getSqlLike()); 384 query.greaterThan("key1", "value", "too more", 4); 385 console.info("should throw exception on invalid arguments"); 386 expect(null).assertFail(); 387 } catch (e) { 388 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 389 } 390 query = null; 391 done(); 392 }) 393 394 /** 395 * @tc.name QueryLessThanTest001 396 * @tc.desc Test Js Api Query.LessThan() testcase 001 397 * @tc.type: FUNC 398 * @tc.require: issueNumber 399 */ 400 it('QueryLessThanTest001', 0, async function(done) { 401 var query = null; 402 try { 403 query = new ddm.Query(); 404 expect("").assertEqual(query.getSqlLike()); 405 query.lessThan("key1", 5); 406 query.lessThan("key2", 5.0); 407 query.lessThan("key3", true); 408 query.lessThan("key4", "string"); 409 expect(query.getSqlLike() !== "").assertTrue(); 410 console.info("query is " + query.getSqlLike()); 411 } catch (e) { 412 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 413 } 414 query = null; 415 done(); 416 }) 417 418 /** 419 * @tc.name QueryLessThanTest002 420 * @tc.desc Test Js Api Query.LessThan() testcase 002 421 * @tc.type: FUNC 422 * @tc.require: issueNumber 423 */ 424 it('QueryLessThanTest002', 0, async function(done) { 425 var query = null; 426 try { 427 query = new ddm.Query(); 428 expect("").assertEqual(query.getSqlLike()); 429 query.lessThan("key", 5); 430 query.reset(); 431 query.lessThan("key0", 5).lessThan("key1", "v5").lessThan("key3", false); 432 expect(query.getSqlLike() !== "").assertTrue(); 433 console.info("query is " + query.getSqlLike()); 434 } catch (e) { 435 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 436 expect(null).assertTrue(); 437 } 438 query = null; 439 done(); 440 }) 441 442 /** 443 * @tc.name QueryLessThanTest003 444 * @tc.desc Test Js Api Query.LessThan() testcase 003 445 * @tc.type: FUNC 446 * @tc.require: issueNumber 447 */ 448 it('QueryLessThanTest003', 0, async function(done) { 449 var query = null; 450 try { 451 query = new ddm.Query(); 452 expect("").assertEqual(query.getSqlLike()); 453 query.lessThan("key2", NaN); 454 console.info("query is " + query.getSqlLike()); 455 } catch (e) { 456 expect(null).assertFail(); 457 } 458 query = null; 459 done(); 460 }) 461 462 /** 463 * @tc.name QueryLessThanTest004 464 * @tc.desc Test Js Api Query.LessThan() testcase 004 465 * @tc.type: FUNC 466 * @tc.require: issueNumber 467 */ 468 it('QueryLessThanTest004', 0, async function(done) { 469 var query = null; 470 try { 471 query = new ddm.Query(); 472 expect("").assertEqual(query.getSqlLike()); 473 query.lessThan("key1", "value", "too more", 4); 474 console.info("query is " + query.getSqlLike()); 475 expect(null).assertFail(); 476 } catch (e) { 477 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 478 } 479 query = null; 480 done(); 481 }) 482 483 /** 484 * @tc.name QueryGreaterThanOrEqualToTest001 485 * @tc.desc Test Js Api Query.GreaterThanOrEqualTo() testcase 001 486 * @tc.type: FUNC 487 * @tc.require: issueNumber 488 */ 489 it('QueryGreaterThanOrEqualToTest001', 0, async function(done) { 490 var query = null; 491 try { 492 query = new ddm.Query(); 493 expect("").assertEqual(query.getSqlLike()); 494 query.greaterThanOrEqualTo("key1", 5); 495 query.greaterThanOrEqualTo("key2", 5.0); 496 query.greaterThanOrEqualTo("key3", true); 497 query.greaterThanOrEqualTo("key4", "string"); 498 expect(query.getSqlLike() !== "").assertTrue(); 499 console.info("query is " + query.getSqlLike()); 500 } catch (e) { 501 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 502 expect(null).assertFail(); 503 } 504 query = null; 505 done(); 506 }) 507 508 /** 509 * @tc.name QueryGreaterThanOrEqualToTest002 510 * @tc.desc Test Js Api Query.GreaterThanOrEqualTo() testcase 002 511 * @tc.type: FUNC 512 * @tc.require: issueNumber 513 */ 514 it('QueryGreaterThanOrEqualToTest002', 0, async function(done) { 515 var query = null; 516 try { 517 query = new ddm.Query(); 518 expect("").assertEqual(query.getSqlLike()); 519 query.greaterThanOrEqualTo("key", 5); 520 query.reset(); 521 query.greaterThanOrEqualTo("key0", 5) 522 .greaterThanOrEqualTo("key1", "v5") 523 .greaterThanOrEqualTo("key3", false); 524 expect(query.getSqlLike() !== "").assertTrue(); 525 console.info("query is " + query.getSqlLike()); 526 } catch (e) { 527 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 528 expect(null).assertFail(); 529 } 530 query = null; 531 done(); 532 }) 533 534 /** 535 * @tc.name QueryGreaterThanOrEqualToTest003 536 * @tc.desc Test Js Api Query.GreaterThanOrEqualTo() testcase 003 537 * @tc.type: FUNC 538 * @tc.require: issueNumber 539 */ 540 it('QueryGreaterThanOrEqualToTest003', 0, async function(done) { 541 var query = null; 542 try { 543 query = new ddm.Query(); 544 expect("").assertEqual(query.getSqlLike()); 545 query.greaterThanOrEqualTo("key2", NaN); 546 expect(query.getSqlLike() !== "").assertTrue(); 547 console.info("query is " + query.getSqlLike()); 548 } catch (e) { 549 expect(null).assertFail(); 550 } 551 query = null; 552 done(); 553 }) 554 555 /** 556 * @tc.name QueryGreaterThanOrEqualToTest004 557 * @tc.desc Test Js Api Query.GreaterThanOrEqualTo() testcase 004 558 * @tc.type: FUNC 559 * @tc.require: issueNumber 560 */ 561 it('QueryGreaterThanOrEqualToTest004', 0, async function(done) { 562 var query = null; 563 try { 564 query = new ddm.Query(); 565 expect("").assertEqual(query.getSqlLike()); 566 query.greaterThanOrEqualTo("key1", "value", "too more", 4); 567 console.info("should throw exception on invalid arguments"); 568 expect(null).assertFail(); 569 } catch (e) { 570 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 571 } 572 query = null; 573 done(); 574 }) 575 576 /** 577 * @tc.name QueryLessThanOrEqualToTest001 578 * @tc.desc Test Js Api Query.LessThanOrEqualTo() testcase 001 579 * @tc.type: FUNC 580 * @tc.require: issueNumber 581 */ 582 it('QueryLessThanOrEqualToTest001', 0, async function(done) { 583 var query = null; 584 try { 585 query = new ddm.Query(); 586 expect("").assertEqual(query.getSqlLike()); 587 query.lessThanOrEqualTo("key1", 5); 588 query.lessThanOrEqualTo("key2", 5.0); 589 query.lessThanOrEqualTo("key3", true); 590 query.lessThanOrEqualTo("key4", "string"); 591 expect(query.getSqlLike() !== "").assertTrue(); 592 console.info("query is " + query.getSqlLike()); 593 } catch (e) { 594 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 595 expect(null).assertFail(); 596 } 597 query = null; 598 done(); 599 }) 600 601 /** 602 * @tc.name QueryLessThanOrEqualToTest002 603 * @tc.desc Test Js Api Query.LessThanOrEqualTo() testcase 002 604 * @tc.type: FUNC 605 * @tc.require: issueNumber 606 */ 607 it('QueryLessThanOrEqualToTest002', 0, async function(done) { 608 var query = null; 609 try { 610 query = new ddm.Query(); 611 expect("").assertEqual(query.getSqlLike()); 612 query.lessThanOrEqualTo("key", 5); 613 query.reset(); 614 query.lessThanOrEqualTo("key0", 5).lessThanOrEqualTo("key1", "v5").lessThanOrEqualTo("key3", false); 615 expect(query.getSqlLike() !== "").assertTrue(); 616 console.info("query is " + query.getSqlLike()); 617 } catch (e) { 618 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 619 expect(null).assertFail(); 620 } 621 query = null; 622 done(); 623 }) 624 625 /** 626 * @tc.name QueryLessThanOrEqualToTest003 627 * @tc.desc Test Js Api Query.LessThanOrEqualTo() testcase 003 628 * @tc.type: FUNC 629 * @tc.require: issueNumber 630 */ 631 it('QueryLessThanOrEqualToTest003', 0, async function(done) { 632 var query = null; 633 try { 634 query = new ddm.Query(); 635 expect("").assertEqual(query.getSqlLike()); 636 query.lessThanOrEqualTo("key2", NaN); 637 console.info("query is " + query.getSqlLike()); 638 } catch (e) { 639 expect(null).assertFail(); 640 } 641 query = null; 642 done(); 643 }) 644 645 /** 646 * @tc.name QueryLessThanOrEqualToTest004 647 * @tc.desc Test Js Api Query.LessThanOrEqualTo() testcase 004 648 * @tc.type: FUNC 649 * @tc.require: issueNumber 650 */ 651 it('QueryLessThanOrEqualToTest004', 0, async function(done) { 652 var query = null; 653 try { 654 query = new ddm.Query(); 655 expect("").assertEqual(query.getSqlLike()); 656 query.lessThanOrEqualTo("key1", "value", "too more", 4); 657 console.info("should throw exception on invalid arguments"); 658 expect(null).assertFail(); 659 } catch (e) { 660 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 661 } 662 query = null; 663 done(); 664 }) 665 666 /** 667 * @tc.name QueryIsNullTest001 668 * @tc.desc Test Js Api Query.IsNull() testcase 001 669 * @tc.type: FUNC 670 * @tc.require: issueNumber 671 */ 672 it('QueryIsNullTest001', 0, async function(done) { 673 var query = null; 674 try { 675 query = new ddm.Query(); 676 expect("").assertEqual(query.getSqlLike()); 677 query.isNull("key"); 678 query.isNull("key2"); 679 expect(query.getSqlLike() !== "").assertTrue(); 680 console.info("query is " + query.getSqlLike()); 681 } catch (e) { 682 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 683 expect(null).assertFail(); 684 } 685 query = null; 686 done(); 687 }) 688 689 /** 690 * @tc.name QueryIsNullTest002 691 * @tc.desc Test Js Api Query.IsNull() testcase 002 692 * @tc.type: FUNC 693 * @tc.require: issueNumber 694 */ 695 it('QueryIsNullTest002', 0, async function(done) { 696 var query = null; 697 try { 698 query = new ddm.Query(); 699 expect("").assertEqual(query.getSqlLike()); 700 query.isNull("key").notEqualTo("key1", 4).isNull("key2"); 701 expect(query.getSqlLike() !== "").assertTrue(); 702 console.info("query is " + query.getSqlLike()); 703 } catch (e) { 704 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 705 expect(null).assertFail(); 706 } 707 query = null; 708 done(); 709 }) 710 711 /** 712 * @tc.name QueryIsNullTest003 713 * @tc.desc Test Js Api Query.IsNull() testcase 003 714 * @tc.type: FUNC 715 * @tc.require: issueNumber 716 */ 717 it('QueryIsNullTest003', 0, async function(done) { 718 var query = null; 719 try { 720 query = new ddm.Query(); 721 expect("").assertEqual(query.getSqlLike()); 722 query.isNull("key", 0); 723 console.info("should throw exception on invalid arguments"); 724 expect(null).assertFail(); 725 } catch (e) { 726 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 727 } 728 query = null; 729 done(); 730 }) 731 732 /** 733 * @tc.name QueryIsNullTest004 734 * @tc.desc Test Js Api Query.IsNull() testcase 004 735 * @tc.type: FUNC 736 * @tc.require: issueNumber 737 */ 738 it('QueryIsNullTest004', 0, async function(done) { 739 var query = null; 740 try { 741 query = new ddm.Query(); 742 expect("").assertEqual(query.getSqlLike()); 743 query.isNull(0); 744 console.info("should throw exception on invalid arguments"); 745 expect(null).assertFail(); 746 } catch (e) { 747 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 748 } 749 query = null; 750 done(); 751 }) 752 753 /* 754 * ======================================================================================= 755 * Int8Array | INTEGER 756 * Uint8Array | INTEGER 757 * Uint8ClampedArray | INTEGER 758 * Int16Array | INTEGER 759 * Uint16Array | INTEGER 760 * Int32Array | INTEGER 761 * Uint32Array | LONG 762 * Float32Array | DOUBLE 763 * Float64Array | DOUBLE 764 * BigInt64Array | ERROR: cannot convert to bigint 765 * BigUint64Array | ERROR: cannot convert to bigint 766 * ======================================================================================= 767 * Array | DOUBLE * not-typedArray treated as array of double. 768 */ 769 770 /** 771 * @tc.name QueryInNumberTest001 772 * @tc.desc Test Js Api Query.InNumber() testcase 001 773 * @tc.type: FUNC 774 * @tc.require: issueNumber 775 */ 776 it('QueryInNumberTest001', 0, async function(done) { 777 var query = null; 778 try { 779 query = new ddm.Query(); 780 expect("").assertEqual(query.getSqlLike()); 781 console.info("testInNumber001 start "); 782 var i8 = new Int8Array([-21,31]); 783 query.reset().inNumber("key", i8); 784 console.info("inNumber(Int8Array([-21,31]) => " + query.getSqlLike()); 785 var u8 = new Uint8Array([-21,31]); 786 query.reset().inNumber("key", u8); 787 console.info("inNumber(Uint8Array([-21,31]) => " + query.getSqlLike()); 788 var c8 = new Uint8ClampedArray([-21,31]); 789 query.reset().inNumber("key", c8); 790 console.info("inNumber(Uint8Array([-21,31]) => " + query.getSqlLike()); 791 var i16 = new Int16Array([-21,31]); 792 query.reset().inNumber("key", i16); 793 console.info("inNumber(Int16Array([-21,31]) => " + query.getSqlLike()); 794 var u16 = new Uint16Array([-21,31]); 795 query.reset().inNumber("key", u16); 796 console.info("inNumber(Uint16Array([-21,31]) => " + query.getSqlLike()); 797 var i32 = new Int32Array([-21, 31]); 798 query.reset().inNumber("key", i32); 799 console.info("inNumber(Int32Array([-21,31]) => " + query.getSqlLike()); 800 var u32 = new Uint32Array([-21, 31]); 801 query.reset().inNumber("key", u32); 802 console.info("inNumber(UInt32Array([-21,31]) => " + query.getSqlLike()); 803 var f32 = new Float32Array([-21, 31]); 804 query.reset().inNumber("key", f32); 805 console.info("inNumber(Float32Array([-21,31]) => " + query.getSqlLike()); 806 var f32e = new Float32Array([21, 31, "a"]); // "a" will be ignored as not a float. 807 query.reset().inNumber("key", f32e); 808 console.info("inNumber(Float32Array([-21,31, 'a']) => " + query.getSqlLike()); 809 var f64 = new Float64Array([-21, 31]); 810 query.reset().inNumber("key", f64); 811 console.info("inNumber(Float64Array([-21,31]) => " + query.getSqlLike()); 812 query.reset(); 813 } catch (e) { 814 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 815 expect(null).assertFail(); 816 } 817 query = null; 818 done(); 819 }) 820 821 /** 822 * @tc.name QueryInNumberTest002 823 * @tc.desc Test Js Api Query.InNumber() testcase 002 824 * @tc.type: FUNC 825 * @tc.require: issueNumber 826 */ 827 it('QueryInNumberTest002', 0, async function(done) { 828 var query = null; 829 try { 830 query = new ddm.Query(); 831 expect("").assertEqual(query.getSqlLike()); 832 query.inNumber("key", [1, 2.3, 987654]). 833 inNumber("key2", [0x10abcdef]). 834 inNumber("key2", [0xf0123456]). 835 inNumber("key2", [0b10101]); 836 expect(query.getSqlLike() !== "").assertTrue(); 837 console.info("query is " + query.getSqlLike()); 838 } catch (e) { 839 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 840 expect(null).assertFail(); 841 } 842 query = null; 843 done(); 844 }) 845 846 /** 847 * @tc.name QueryInNumberTest003 848 * @tc.desc Test Js Api Query.InNumber() testcase 003 849 * @tc.type: FUNC 850 * @tc.require: issueNumber 851 */ 852 it('QueryInNumberTest003', 0, async function(done) { 853 var query = null; 854 try { 855 query = new ddm.Query(); 856 expect("").assertEqual(query.getSqlLike()); 857 query.inNumber("key", 0); 858 console.info("should throw exception on invalid arguments"); 859 expect(null).assertFail(); 860 } catch (e) { 861 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 862 } 863 query = null; 864 done(); 865 }) 866 867 /** 868 * @tc.name QueryInNumberTest004 869 * @tc.desc Test Js Api Query.InNumber() testcase 004 870 * @tc.type: FUNC 871 * @tc.require: issueNumber 872 */ 873 it('QueryInNumberTest004', 0, async function(done) { 874 var query = null; 875 try { 876 query = new ddm.Query(); 877 expect("").assertEqual(query.getSqlLike()); 878 query.inNumber([0, 1]); 879 console.info("should throw exception on invalid arguments"); 880 expect(null).assertFail(); 881 } catch (e) { 882 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 883 } 884 query = null; 885 done(); 886 }) 887 888 /** 889 * @tc.name QueryInNumberTest005 890 * @tc.desc Test Js Api Query.InNumber() testcase 005 891 * @tc.type: FUNC 892 * @tc.require: issueNumber 893 */ 894 it('QueryInNumberTest005', 0, async function(done) { 895 var query = null; 896 try { 897 query = new ddm.Query(); 898 expect("").assertEqual(query.getSqlLike()); 899 var u64 = new BigUint64Array([21, 31]); 900 query.inNumber("key", u64); 901 var b64 = new BigInt64Array([21, 31]); 902 query.inNumber("key", b64); 903 console.info("should throw exception on invalid arguments"); 904 expect(null).assertFail(); 905 } catch (e) { 906 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 907 } 908 query = null; 909 done(); 910 }) 911 912 /** 913 * @tc.name QueryInNumberTest006 914 * @tc.desc Test Js Api Query.InNumber() testcase 006 915 * @tc.type: FUNC 916 * @tc.require: issueNumber 917 */ 918 it('QueryInNumberTest006', 0, async function(done) { 919 var query = null; 920 try { 921 query = new ddm.Query(); 922 console.info("typeof([1, 2, 97])" + typeof([1, 2, 97])) 923 console.info("typeof([1, 2, 97][0])" + typeof([1, 2, 97][0])) 924 query.inNumber("key", [1, 2, 97]); 925 console.info("inNumber([1, 2, 97]) => " + query.getSqlLike()); 926 query.reset(); 927 query.inNumber("key1", [-1, 3, 987654.123, 0xabc123456]); 928 console.info("inNumber([1, 2, 0xa1234567890123456]) => " + query.getSqlLike()); 929 query.reset(); 930 query.inNumber("key2", [-1, 3, -987654.123, 0xabc123456]); 931 console.info("inNumber([1, 2, 0xa1234567890123456]) => " + query.getSqlLike()); 932 query.reset(); 933 query.inNumber("key3", [-1, 4, -987654.123, Number.MAX_VALUE]); 934 console.info("inNumber([1, 2, Number.MAX_VALUE]) => " + query.getSqlLike()); 935 query.reset(); 936 query.inNumber("key4", [1, -2.3, Number.MIN_VALUE, Number.MAX_VALUE]); 937 console.info("inNumber([1, -2.3, Number.MAX_VALUE]) => " + query.getSqlLike()); 938 expect(query.getSqlLike() !== "").assertTrue(); 939 console.info("query is " + query.getSqlLike()); 940 query.reset(); 941 } catch (e) { 942 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 943 expect(null).assertFail(); 944 } 945 query = null; 946 done(); 947 }) 948 949 /** 950 * @tc.name QueryInStringTest001 951 * @tc.desc Test Js Api Query.InString() testcase 001 952 * @tc.type: FUNC 953 * @tc.require: issueNumber 954 */ 955 it('QueryInStringTest001', 0, async function(done) { 956 var query = null; 957 try { 958 query = new ddm.Query(); 959 expect("").assertEqual(query.getSqlLike()); 960 query.inString("key", ["a2z" , 'z2a']); 961 query.inString("key2", ["AAA" ]); 962 console.info("query is " + query.getSqlLike()); 963 expect(query.getSqlLike() !== "").assertTrue(); 964 } catch (e) { 965 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 966 expect(null).assertFail(); 967 } 968 query = null; 969 done(); 970 }) 971 972 /** 973 * @tc.name QueryInStringTest002 974 * @tc.desc Test Js Api Query.InString() testcase 002 975 * @tc.type: FUNC 976 * @tc.require: issueNumber 977 */ 978 it('QueryInStringTest002', 0, async function(done) { 979 var query = null; 980 try { 981 query = new ddm.Query(); 982 expect("").assertEqual(query.getSqlLike()); 983 query.inString("key", ["a2z" , 'z2a']) 984 .inString("key2", ["AAA" ]) 985 .inString("key2", ["AAA", "AAABBB","CCCAAA" ]); 986 expect(query.getSqlLike() !== "").assertTrue(); 987 console.info("query is " + query.getSqlLike()); 988 } catch (e) { 989 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 990 expect(null).assertFail(); 991 } 992 query = null; 993 done(); 994 }) 995 996 /** 997 * @tc.name QueryInStringTest003 998 * @tc.desc Test Js Api Query.InString() testcase 003 999 * @tc.type: FUNC 1000 * @tc.require: issueNumber 1001 */ 1002 it('QueryInStringTest003', 0, async function(done) { 1003 var query = null; 1004 try { 1005 query = new ddm.Query(); 1006 expect("").assertEqual(query.getSqlLike()); 1007 query.inString("key", 0); 1008 console.info("should throw exception on invalid arguments"); 1009 expect(null).assertFail(); 1010 } catch (e) { 1011 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1012 } 1013 query = null; 1014 done(); 1015 }) 1016 1017 /** 1018 * @tc.name QueryInStringTest004 1019 * @tc.desc Test Js Api Query.InString() testcase 004 1020 * @tc.type: FUNC 1021 * @tc.require: issueNumber 1022 */ 1023 it('QueryInStringTest004', 0, async function(done) { 1024 var query = null; 1025 try { 1026 query = new ddm.Query(); 1027 expect("").assertEqual(query.getSqlLike()); 1028 query.inString("key", [0, 1]); 1029 console.info("should throw exception on invalid arguments"); 1030 expect(null).assertFail(); 1031 } catch (e) { 1032 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1033 } 1034 query = null; 1035 done(); 1036 }) 1037 1038 /** 1039 * @tc.name QueryNotInNumberTest001 1040 * @tc.desc Test Js Api Query.NotInNumber() testcase 001 1041 * @tc.type: FUNC 1042 * @tc.require: issueNumber 1043 */ 1044 it('QueryNotInNumberTest001', 0, async function(done) { 1045 var query = null; 1046 try { 1047 query = new ddm.Query(); 1048 expect("").assertEqual(query.getSqlLike()); 1049 query.notInNumber("key", [1, 2]); 1050 query.notInNumber("key", [1000]); 1051 expect(query.getSqlLike() !== "").assertTrue(); 1052 console.info("query is " + query.getSqlLike()); 1053 } catch (e) { 1054 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1055 expect(null).assertFail(); 1056 } 1057 query = null; 1058 done(); 1059 }) 1060 1061 /** 1062 * @tc.name QueryNotInNumberTest002 1063 * @tc.desc Test Js Api Query.NotInNumber() testcase 002 1064 * @tc.type: FUNC 1065 * @tc.require: issueNumber 1066 */ 1067 it('QueryNotInNumberTest002', 0, async function(done) { 1068 var query = null; 1069 try { 1070 query = new ddm.Query(); 1071 expect("").assertEqual(query.getSqlLike()); 1072 query.notInNumber("key", [1, 2, 3]).notInNumber("key", [1, 7, 8]).notEqualTo("kkk", 5); 1073 expect(query.getSqlLike() !== "").assertTrue(); 1074 console.info("query is " + query.getSqlLike()); 1075 } catch (e) { 1076 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1077 expect(null).assertFail(); 1078 } 1079 query = null; 1080 done(); 1081 }) 1082 1083 /** 1084 * @tc.name QueryNotInNumberTest003 1085 * @tc.desc Test Js Api Query.NotInNumber() testcase 003 1086 * @tc.type: FUNC 1087 * @tc.require: issueNumber 1088 */ 1089 it('QueryNotInNumberTest003', 0, async function(done) { 1090 var query = null; 1091 try { 1092 query = new ddm.Query(); 1093 expect("").assertEqual(query.getSqlLike()); 1094 query.notInNumber("key", [1], 2); 1095 console.info("should throw exception on invalid arguments"); 1096 expect(null).assertFail(); 1097 } catch (e) { 1098 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1099 } 1100 query = null; 1101 done(); 1102 }) 1103 1104 /** 1105 * @tc.name QueryNotInNumberTest004 1106 * @tc.desc Test Js Api Query.NotInNumber() testcase 004 1107 * @tc.type: FUNC 1108 * @tc.require: issueNumber 1109 */ 1110 it('QueryNotInNumberTest004', 0, async function(done) { 1111 var query = null; 1112 try { 1113 query = new ddm.Query(); 1114 expect("").assertEqual(query.getSqlLike()); 1115 query.notInNumber("key", ["string"]); 1116 expect(query.getSqlLike() !== "").assertTrue(); 1117 console.info("should throw exception on invalid arguments"); 1118 expect(null).assertFail(); 1119 } catch (e) { 1120 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1121 } 1122 query = null; 1123 done(); 1124 }) 1125 1126 /** 1127 * @tc.name QueryNotInStringTest001 1128 * @tc.desc Test Js Api Query.NotInString() testcase 001 1129 * @tc.type: FUNC 1130 * @tc.require: issueNumber 1131 */ 1132 it('QueryNotInStringTest001', 0, async function(done) { 1133 var query = null; 1134 try { 1135 query = new ddm.Query(); 1136 expect("").assertEqual(query.getSqlLike()); 1137 query.notInString("key", ["v1", "v2"]); 1138 query.notInString("key", ["v1", "NaN"]); 1139 expect(query.getSqlLike() !== "").assertTrue(); 1140 console.info("query is " + query.getSqlLike()); 1141 } catch (e) { 1142 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1143 expect(null).assertFail(); 1144 } 1145 query = null; 1146 done(); 1147 }) 1148 1149 /** 1150 * @tc.name QueryNotInStringTest002 1151 * @tc.desc Test Js Api Query.NotInString() testcase 002 1152 * @tc.type: FUNC 1153 * @tc.require: issueNumber 1154 */ 1155 it('QueryNotInStringTest002', 0, async function(done) { 1156 var query = null; 1157 try { 1158 query = new ddm.Query(); 1159 expect("").assertEqual(query.getSqlLike()); 1160 query.notInString("key", ["v1", "v2", "v3"]).notEqualTo("kkk", "v3"); 1161 expect(query.getSqlLike() !== "").assertTrue(); 1162 console.info("query is " + query.getSqlLike()); 1163 } catch (e) { 1164 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1165 expect(null).assertFail(); 1166 } 1167 query = null; 1168 done(); 1169 }) 1170 1171 /** 1172 * @tc.name QueryNotInStringTest003 1173 * @tc.desc Test Js Api Query.NotInString() testcase 003 1174 * @tc.type: FUNC 1175 * @tc.require: issueNumber 1176 */ 1177 it('QueryNotInStringTest003', 0, async function(done) { 1178 var query = null; 1179 try { 1180 query = new ddm.Query(); 1181 expect("").assertEqual(query.getSqlLike()); 1182 query.notInString("key", ["", "abccd"], 2); 1183 console.info("should throw exception on invalid arguments"); 1184 expect(null).assertFail(); 1185 } catch (e) { 1186 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1187 } 1188 query = null; 1189 done(); 1190 }) 1191 1192 /** 1193 * @tc.name QueryNotInStringTest004 1194 * @tc.desc Test Js Api Query.NotInString() testcase 004 1195 * @tc.type: FUNC 1196 * @tc.require: issueNumber 1197 */ 1198 it('QueryNotInStringTest004', 0, async function(done) { 1199 var query = null; 1200 try { 1201 query = new ddm.Query(); 1202 expect("").assertEqual(query.getSqlLike()); 1203 query.notInString("key", [1, 2]); 1204 console.info("should throw exception on invalid arguments"); 1205 expect(null).assertFail(); 1206 } catch (e) { 1207 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1208 } 1209 query = null; 1210 done(); 1211 }) 1212 1213 /** 1214 * @tc.name QueryLikeTest001 1215 * @tc.desc Test Js Api Query.Like() testcase 001 1216 * @tc.type: FUNC 1217 * @tc.require: issueNumber 1218 */ 1219 it('QueryLikeTest001', 0, async function(done) { 1220 var query = null; 1221 try { 1222 query = new ddm.Query(); 1223 expect("").assertEqual(query.getSqlLike()); 1224 query.like("key", "v1"); 1225 query.like("key2", "v2"); 1226 expect(query.getSqlLike() !== "").assertTrue(); 1227 console.info("query is " + query.getSqlLike()); 1228 } catch (e) { 1229 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1230 expect(null).assertFail(); 1231 } 1232 query = null; 1233 done(); 1234 }) 1235 1236 /** 1237 * @tc.name QueryLikeTest002 1238 * @tc.desc Test Js Api Query.Like() testcase 002 1239 * @tc.type: FUNC 1240 * @tc.require: issueNumber 1241 */ 1242 it('QueryLikeTest002', 0, async function(done) { 1243 var query = null; 1244 try { 1245 query = new ddm.Query(); 1246 expect("").assertEqual(query.getSqlLike()); 1247 query.like("key", "v1").like("key", "v3").like("key", "v2"); 1248 expect(query.getSqlLike() !== "").assertTrue(); 1249 console.info("query is " + query.getSqlLike()); 1250 } catch (e) { 1251 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1252 expect(null).assertFail(); 1253 } 1254 query = null; 1255 done(); 1256 }) 1257 1258 /** 1259 * @tc.name QueryLikeTest003 1260 * @tc.desc Test Js Api Query.Like() testcase 003 1261 * @tc.type: FUNC 1262 * @tc.require: issueNumber 1263 */ 1264 it('QueryLikeTest003', 0, async function(done) { 1265 var query = null; 1266 try { 1267 query = new ddm.Query(); 1268 expect("").assertEqual(query.getSqlLike()); 1269 query.like("key", 0); 1270 console.info("should throw exception on invalid arguments"); 1271 expect(null).assertFail(); 1272 } catch (e) { 1273 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1274 } 1275 query = null; 1276 done(); 1277 }) 1278 1279 /** 1280 * @tc.name QueryLikeTest004 1281 * @tc.desc Test Js Api Query.Like() testcase 004 1282 * @tc.type: FUNC 1283 * @tc.require: issueNumber 1284 */ 1285 it('QueryLikeTest004', 0, async function(done) { 1286 var query = null; 1287 try { 1288 query = new ddm.Query(); 1289 expect("").assertEqual(query.getSqlLike()); 1290 query.like("key", "str1", "str2"); 1291 console.info("should throw exception on invalid arguments"); 1292 expect(null).assertFail(); 1293 } catch (e) { 1294 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1295 } 1296 query = null; 1297 done(); 1298 }) 1299 1300 /** 1301 * @tc.name QueryUnlikeTest001 1302 * @tc.desc Test Js Api Query.Unlike() testcase 001 1303 * @tc.type: FUNC 1304 * @tc.require: issueNumber 1305 */ 1306 it('QueryUnlikeTest001', 0, async function(done) { 1307 var query = null; 1308 try { 1309 query = new ddm.Query(); 1310 expect("").assertEqual(query.getSqlLike()); 1311 query.unlike("key", "v1"); 1312 expect(query.getSqlLike() !== "").assertTrue(); 1313 console.info("query is " + query.getSqlLike()); 1314 } catch (e) { 1315 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1316 expect(null).assertFail(); 1317 } 1318 query = null; 1319 done(); 1320 }) 1321 1322 /** 1323 * @tc.name QueryUnlikeTest002 1324 * @tc.desc Test Js Api Query.Unlike() testcase 002 1325 * @tc.type: FUNC 1326 * @tc.require: issueNumber 1327 */ 1328 it('QueryUnlikeTest002', 0, async function(done) { 1329 var query = null; 1330 try { 1331 query = new ddm.Query(); 1332 expect("").assertEqual(query.getSqlLike()); 1333 query.unlike("key", "v1").unlike("key", "v3").unlike("key", "v2"); 1334 expect(query.getSqlLike() !== "").assertTrue(); 1335 console.info("query is " + query.getSqlLike()); 1336 } catch (e) { 1337 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1338 expect(null).assertFail(); 1339 } 1340 query = null; 1341 done(); 1342 }) 1343 1344 /** 1345 * @tc.name QueryUnlikeTest003 1346 * @tc.desc Test Js Api Query.Unlike() testcase 003 1347 * @tc.type: FUNC 1348 * @tc.require: issueNumber 1349 */ 1350 it('QueryUnlikeTest003', 0, async function(done) { 1351 var query = null; 1352 try { 1353 query = new ddm.Query(); 1354 expect("").assertEqual(query.getSqlLike()); 1355 query.unlike("key", 0); 1356 console.info("should throw exception on invalid arguments"); 1357 expect(null).assertFail(); 1358 } catch (e) { 1359 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1360 } 1361 query = null; 1362 done(); 1363 }) 1364 1365 /** 1366 * @tc.name QueryUnlikeTest004 1367 * @tc.desc Test Js Api Query.Unlike() testcase 004 1368 * @tc.type: FUNC 1369 * @tc.require: issueNumber 1370 */ 1371 it('QueryUnlikeTest004', 0, async function(done) { 1372 var query = null; 1373 try { 1374 query = new ddm.Query(); 1375 expect("").assertEqual(query.getSqlLike()); 1376 query.unlike("key", "str1", "str2"); 1377 console.info("should throw exception on invalid arguments"); 1378 expect(null).assertFail(); 1379 } catch (e) { 1380 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1381 } 1382 query = null; 1383 done(); 1384 }) 1385 1386 /** 1387 * @tc.name QueryAndTest001 1388 * @tc.desc Test Js Api Query.And() testcase 001 1389 * @tc.type: FUNC 1390 * @tc.require: issueNumber 1391 */ 1392 it('QueryAndTest001', 0, async function(done) { 1393 var query = null; 1394 try { 1395 query = new ddm.Query(); 1396 expect("").assertEqual(query.getSqlLike()); 1397 query.notEqualTo("key", 0); 1398 query.and(); 1399 query.notEqualTo("key", "v1"); 1400 expect(query.getSqlLike() !== "").assertTrue(); 1401 console.info("query is " + query.getSqlLike()); 1402 } catch (e) { 1403 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1404 expect(null).assertFail(); 1405 } 1406 query = null; 1407 done(); 1408 }) 1409 1410 /** 1411 * @tc.name QueryAndTest002 1412 * @tc.desc Test Js Api Query.And() testcase 002 1413 * @tc.type: FUNC 1414 * @tc.require: issueNumber 1415 */ 1416 it('QueryAndTest002', 0, async function(done) { 1417 var query = null; 1418 try { 1419 query = new ddm.Query(); 1420 expect("").assertEqual(query.getSqlLike()); 1421 query.equalTo("key1", 0).and().equalTo("key2", "v1"); 1422 expect(query.getSqlLike() !== "").assertTrue(); 1423 console.info("query is " + query.getSqlLike()); 1424 } catch (e) { 1425 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1426 expect(null).assertFail(); 1427 } 1428 query = null; 1429 done(); 1430 }) 1431 1432 /** 1433 * @tc.name QueryAndTest003 1434 * @tc.desc Test Js Api Query.And() testcase 003 1435 * @tc.type: FUNC 1436 * @tc.require: issueNumber 1437 */ 1438 it('QueryAndTest003', 0, async function(done) { 1439 var query = null; 1440 try { 1441 query = new ddm.Query(); 1442 expect("").assertEqual(query.getSqlLike()); 1443 query.notEqualTo("key", 0).and().notEqualTo("key", 1).and(); 1444 expect(query.getSqlLike() !== "").assertTrue(); 1445 query.reset(); 1446 console.info("query is " + query.getSqlLike()); 1447 } catch (e) { 1448 expect(null).assertFail(); 1449 } 1450 query = null; 1451 done(); 1452 }) 1453 1454 /** 1455 * @tc.name QueryAndTest004 1456 * @tc.desc Test Js Api Query.And() testcase 004 1457 * @tc.type: FUNC 1458 * @tc.require: issueNumber 1459 */ 1460 it('QueryAndTest004', 0, async function(done) { 1461 var query = null; 1462 try { 1463 query = new ddm.Query(); 1464 expect("").assertEqual(query.getSqlLike()); 1465 query.notEqualTo("key", 0).and(1).notInNumber("key", [1, 3]); 1466 console.info("should throw exception on invalid arguments"); 1467 expect(null).assertFail(); 1468 } catch (e) { 1469 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1470 } 1471 query = null; 1472 done(); 1473 }) 1474 1475 /** 1476 * @tc.name QueryOrTest001 1477 * @tc.desc Test Js Api Query.Or() testcase 001 1478 * @tc.type: FUNC 1479 * @tc.require: issueNumber 1480 */ 1481 it('QueryOrTest001', 0, async function(done) { 1482 var query = null; 1483 try { 1484 query = new ddm.Query(); 1485 expect("").assertEqual(query.getSqlLike()); 1486 query.notEqualTo("key", 0); 1487 query.or(); 1488 query.notEqualTo("key", "v1"); 1489 expect(query.getSqlLike() !== "").assertTrue(); 1490 console.info("query is " + query.getSqlLike()); 1491 } catch (e) { 1492 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1493 expect(null).assertFail(); 1494 } 1495 query = null; 1496 done(); 1497 }) 1498 1499 /** 1500 * @tc.name QueryOrTest002 1501 * @tc.desc Test Js Api Query.Or() testcase 002 1502 * @tc.type: FUNC 1503 * @tc.require: issueNumber 1504 */ 1505 it('QueryOrTest002', 0, async function(done) { 1506 var query = null; 1507 try { 1508 query = new ddm.Query(); 1509 expect("").assertEqual(query.getSqlLike()); 1510 query.equalTo("key1", 0).or().equalTo("key2", "v1"); 1511 expect(query.getSqlLike() !== "").assertTrue(); 1512 query.reset(); 1513 console.info("query is " + query.getSqlLike()); 1514 } catch (e) { 1515 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1516 expect(null).assertFail(); 1517 } 1518 query = null; 1519 done(); 1520 }) 1521 1522 /** 1523 * @tc.name QueryOrTest003 1524 * @tc.desc Test Js Api Query.Or() testcase 003 1525 * @tc.type: FUNC 1526 * @tc.require: issueNumber 1527 */ 1528 it('QueryOrTest003', 0, async function(done) { 1529 var query = null; 1530 try { 1531 query = new ddm.Query(); 1532 expect("").assertEqual(query.getSqlLike()); 1533 query.notEqualTo("key", 0).or(); 1534 console.info("or ... sql:" + query.getSqlLike()); 1535 expect(query.getSqlLike() !== "").assertTrue(); 1536 query.reset(); 1537 console.info("query is " + query.getSqlLike()); 1538 } catch (e) { 1539 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1540 expect(null).assertFail(); 1541 } 1542 query = null; 1543 done(); 1544 }) 1545 1546 /** 1547 * @tc.name QueryOrTest004 1548 * @tc.desc Test Js Api Query.Or() testcase 004 1549 * @tc.type: FUNC 1550 * @tc.require: issueNumber 1551 */ 1552 it('QueryOrTest004', 0, async function(done) { 1553 var query = null; 1554 try { 1555 query = new ddm.Query(); 1556 expect("").assertEqual(query.getSqlLike()); 1557 query.notEqualTo("key", 0).or(1).notInNumber("key", [1, 3]); 1558 console.info("should throw exception on invalid arguments"); 1559 expect(null).assertFail(); 1560 } catch (e) { 1561 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1562 } 1563 query = null; 1564 done(); 1565 }) 1566 1567 /** 1568 * @tc.name QueryOrderByAscTest001 1569 * @tc.desc Test Js Api Query.OrderByAsc() testcase 001 1570 * @tc.type: FUNC 1571 * @tc.require: issueNumber 1572 */ 1573 it('QueryOrderByAscTest001', 0, async function(done) { 1574 var query = null; 1575 try { 1576 query = new ddm.Query(); 1577 expect("").assertEqual(query.getSqlLike()); 1578 query.notEqualTo("key", 0); 1579 query.orderByAsc("sortbykey"); 1580 expect(query.getSqlLike() !== "").assertTrue(); 1581 console.info("query is " + query.getSqlLike()); 1582 } catch (e) { 1583 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1584 expect(null).assertFail(); 1585 } 1586 query = null; 1587 done(); 1588 }) 1589 1590 /** 1591 * @tc.name QueryOrderByAscTest002 1592 * @tc.desc Test Js Api Query.OrderByAsc() testcase 002 1593 * @tc.type: FUNC 1594 * @tc.require: issueNumber 1595 */ 1596 it('QueryOrderByAscTest002', 0, async function(done) { 1597 var query = null; 1598 try { 1599 query = new ddm.Query(); 1600 expect("").assertEqual(query.getSqlLike()); 1601 query.notEqualTo("key", "V0").orderByAsc("sortbykey1").orderByAsc("sortbykey2"); 1602 expect(query.getSqlLike() !== "").assertTrue(); 1603 console.info("query is " + query.getSqlLike()); 1604 } catch (e) { 1605 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1606 expect(null).assertFail(); 1607 } 1608 query = null; 1609 done(); 1610 }) 1611 1612 /** 1613 * @tc.name QueryOrderByAscTest003 1614 * @tc.desc Test Js Api Query.OrderByAsc() testcase 003 1615 * @tc.type: FUNC 1616 * @tc.require: issueNumber 1617 */ 1618 it('QueryOrderByAscTest003', 0, async function(done) { 1619 var query = null; 1620 try { 1621 query = new ddm.Query(); 1622 expect("").assertEqual(query.getSqlLike()); 1623 query.notEqualTo("key", false).orderByAsc(1); 1624 console.info("should throw exception on invalid arguments"); 1625 expect(null).assertFail(); 1626 } catch (e) { 1627 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1628 } 1629 query = null; 1630 done(); 1631 }) 1632 1633 /** 1634 * @tc.name QueryOrderByAscTest004 1635 * @tc.desc Test Js Api Query.OrderByAsc() testcase 004 1636 * @tc.type: FUNC 1637 * @tc.require: issueNumber 1638 */ 1639 it('QueryOrderByAscTest004', 0, async function(done) { 1640 var query = null; 1641 try { 1642 query = new ddm.Query(); 1643 expect("").assertEqual(query.getSqlLike()); 1644 query.orderByAsc(); 1645 console.info("should throw exception on invalid arguments"); 1646 expect(null).assertFail(); 1647 } catch (e) { 1648 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1649 } 1650 query = null; 1651 done(); 1652 }) 1653 1654 /** 1655 * @tc.name QueryOrderByDescTest001 1656 * @tc.desc Test Js Api Query.OrderByDesc() testcase 001 1657 * @tc.type: FUNC 1658 * @tc.require: issueNumber 1659 */ 1660 it('QueryOrderByDescTest001', 0, async function(done) { 1661 var query = null; 1662 try { 1663 query = new ddm.Query(); 1664 expect("").assertEqual(query.getSqlLike()); 1665 query.notEqualTo("key", 0); 1666 query.orderByDesc("sortbykey"); 1667 expect(query.getSqlLike() !== "").assertTrue(); 1668 console.info("query is " + query.getSqlLike()); 1669 } catch (e) { 1670 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1671 expect(null).assertFail(); 1672 } 1673 query = null; 1674 done(); 1675 }) 1676 1677 /** 1678 * @tc.name QueryOrderByDescTest002 1679 * @tc.desc Test Js Api Query.OrderByDesc() testcase 002 1680 * @tc.type: FUNC 1681 * @tc.require: issueNumber 1682 */ 1683 it('QueryOrderByDescTest002', 0, async function(done) { 1684 var query = null; 1685 try { 1686 query = new ddm.Query(); 1687 expect("").assertEqual(query.getSqlLike()); 1688 query.notEqualTo("key", "V0").orderByDesc("sortbykey1").orderByDesc("sortbykey2"); 1689 expect(query.getSqlLike() !== "").assertTrue(); 1690 console.info("query is " + query.getSqlLike()); 1691 } catch (e) { 1692 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1693 expect(null).assertFail(); 1694 } 1695 query = null; 1696 done(); 1697 }) 1698 1699 /** 1700 * @tc.name QueryOrderByDescTest003 1701 * @tc.desc Test Js Api Query.OrderByDesc() testcase 003 1702 * @tc.type: FUNC 1703 * @tc.require: issueNumber 1704 */ 1705 it('QueryOrderByDescTest003', 0, async function(done) { 1706 var query = null; 1707 try { 1708 query = new ddm.Query(); 1709 expect("").assertEqual(query.getSqlLike()); 1710 query.notEqualTo("key", false).orderByDesc(1); 1711 console.info("should throw exception on invalid arguments"); 1712 expect(null).assertFail(); 1713 } catch (e) { 1714 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1715 } 1716 query = null; 1717 done(); 1718 }) 1719 1720 /** 1721 * @tc.name QueryOrderByDescTest004 1722 * @tc.desc Test Js Api Query.OrderByDesc() testcase 004 1723 * @tc.type: FUNC 1724 * @tc.require: issueNumber 1725 */ 1726 it('QueryOrderByDescTest004', 0, async function(done) { 1727 var query = null; 1728 try { 1729 query = new ddm.Query(); 1730 expect("").assertEqual(query.getSqlLike()); 1731 query.orderByDesc(); 1732 console.info("should throw exception on invalid arguments"); 1733 expect(null).assertFail(); 1734 } catch (e) { 1735 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1736 } 1737 query = null; 1738 done(); 1739 }) 1740 1741 /** 1742 * @tc.name QueryLimitTest001 1743 * @tc.desc Test Js Api Query.Limit() testcase 001 1744 * @tc.type: FUNC 1745 * @tc.require: issueNumber 1746 */ 1747 it('QueryLimitTest001', 0, async function(done) { 1748 var query = null; 1749 try { 1750 query = new ddm.Query(); 1751 expect("").assertEqual(query.getSqlLike()); 1752 query.notEqualTo("key", "vx"); 1753 query.limit(10, 2); 1754 expect(query.getSqlLike() !== "").assertTrue(); 1755 console.info("query is " + query.getSqlLike()); 1756 } catch (e) { 1757 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1758 expect(null).assertFail(); 1759 } 1760 query = null; 1761 done(); 1762 }) 1763 1764 /** 1765 * @tc.name QueryLimitTest002 1766 * @tc.desc Test Js Api Query.Limit() testcase 002 1767 * @tc.type: FUNC 1768 * @tc.require: issueNumber 1769 */ 1770 it('QueryLimitTest002', 0, async function(done) { 1771 var query = null; 1772 try { 1773 query = new ddm.Query(); 1774 expect("").assertEqual(query.getSqlLike()); 1775 query.notEqualTo("key", "vx").limit(10, 2) 1776 .equalTo("key2", 2).limit(10, 2); 1777 expect(query.getSqlLike() !== "").assertTrue(); 1778 console.info("query is " + query.getSqlLike()); 1779 } catch (e) { 1780 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1781 expect(null).assertFail(); 1782 } 1783 query = null; 1784 done(); 1785 }) 1786 1787 /** 1788 * @tc.name QueryLimitTest003 1789 * @tc.desc Test Js Api Query.Limit() testcase 003 1790 * @tc.type: FUNC 1791 * @tc.require: issueNumber 1792 */ 1793 it('QueryLimitTest003', 0, async function(done) { 1794 var query = null; 1795 try { 1796 query = new ddm.Query(); 1797 expect("").assertEqual(query.getSqlLike()); 1798 query.notEqualTo("key", false).limit(10, 2, "any"); 1799 console.info("should throw exception on invalid arguments"); 1800 expect(null).assertFail(); 1801 console.info("query is " + query.getSqlLike()); 1802 } catch (e) { 1803 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1804 } 1805 query = null; 1806 done(); 1807 }) 1808 1809 /** 1810 * @tc.name QueryLimitTest004 1811 * @tc.desc Test Js Api Query.Limit() testcase 004 1812 * @tc.type: FUNC 1813 * @tc.require: issueNumber 1814 */ 1815 it('QueryLimitTest004', 0, async function(done) { 1816 var query = null; 1817 try { 1818 query = new ddm.Query(); 1819 expect("").assertEqual(query.getSqlLike()); 1820 query.notEqualTo("key", false).limit(10); 1821 console.info("should throw exception on invalid arguments"); 1822 expect(null).assertFail(); 1823 } catch (e) { 1824 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1825 } 1826 query = null; 1827 done(); 1828 }) 1829 1830 /** 1831 * @tc.name QueryLimitTest005 1832 * @tc.desc Test Js Api Query.Limit() testcase 005 1833 * @tc.type: FUNC 1834 * @tc.require: issueNumber 1835 */ 1836 it('QueryLimitTest005', 0, async function(done) { 1837 var query = null; 1838 try { 1839 query = new ddm.Query(); 1840 expect("").assertEqual(query.getSqlLike()); 1841 query.notEqualTo("key", false).limit("any", 10); 1842 console.info("should throw exception on invalid arguments"); 1843 console.info("query is " + query.getSqlLike()); 1844 expect(null).assertFail(); 1845 } catch (e) { 1846 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1847 } 1848 query = null; 1849 done(); 1850 }) 1851 1852 /** 1853 * @tc.name QueryIsNotNullTest001 1854 * @tc.desc Test Js Api Query.IsNotNull() testcase 001 1855 * @tc.type: FUNC 1856 * @tc.require: issueNumber 1857 */ 1858 it('QueryIsNotNullTest001', 0, async function(done) { 1859 var query = null; 1860 try { 1861 query = new ddm.Query(); 1862 expect("").assertEqual(query.getSqlLike()); 1863 query.isNotNull("key"); 1864 expect(query.getSqlLike() !== "").assertTrue(); 1865 console.info("query is " + query.getSqlLike()); 1866 } catch (e) { 1867 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1868 expect(null).assertFail(); 1869 } 1870 query = null; 1871 done(); 1872 }) 1873 1874 /** 1875 * @tc.name QueryIsNotNullTest002 1876 * @tc.desc Test Js Api Query.IsNotNull() testcase 002 1877 * @tc.type: FUNC 1878 * @tc.require: issueNumber 1879 */ 1880 it('QueryIsNotNullTest002', 0, async function(done) { 1881 var query = null; 1882 try { 1883 query = new ddm.Query(); 1884 expect("").assertEqual(query.getSqlLike()); 1885 query.isNotNull("key1").and().notEqualTo("key1", 123); 1886 expect(query.getSqlLike() !== "").assertTrue(); 1887 console.info("query is " + query.getSqlLike()); 1888 } catch (e) { 1889 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1890 expect(null).assertFail(); 1891 } 1892 query = null; 1893 done(); 1894 }) 1895 1896 /** 1897 * @tc.name QueryIsNotNullTest003 1898 * @tc.desc Test Js Api Query.IsNotNull() testcase 003 1899 * @tc.type: FUNC 1900 * @tc.require: issueNumber 1901 */ 1902 it('QueryIsNotNullTest003', 0, async function(done) { 1903 var query = null; 1904 try { 1905 query = new ddm.Query(); 1906 expect("").assertEqual(query.getSqlLike()); 1907 query.isNotNull("key2", "any"); 1908 console.info("should throw exception on invalid arguments"); 1909 expect(null).assertFail(); 1910 } catch (e) { 1911 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1912 } 1913 query = null; 1914 done(); 1915 }) 1916 1917 /** 1918 * @tc.name QueryIsNotNullTest004 1919 * @tc.desc Test Js Api Query.IsNotNull() testcase 004 1920 * @tc.type: FUNC 1921 * @tc.require: issueNumber 1922 */ 1923 it('QueryIsNotNullTest004', 0, async function(done) { 1924 var query = null; 1925 try { 1926 query = new ddm.Query(); 1927 expect("").assertEqual(query.getSqlLike()); 1928 query.isNotNull(1); 1929 console.info("should throw exception on invalid arguments"); 1930 expect(null).assertFail(); 1931 } catch (e) { 1932 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1933 } 1934 query = null; 1935 done(); 1936 }) 1937 1938 /** 1939 * @tc.name QueryBeginGroupTest001 1940 * @tc.desc Test Js Api Query.BeginGroup() testcase 001 1941 * @tc.type: FUNC 1942 * @tc.require: issueNumber 1943 */ 1944 it('QueryBeginGroupTest001', 0, async function(done) { 1945 var query = null; 1946 try { 1947 query = new ddm.Query(); 1948 expect("").assertEqual(query.getSqlLike()); 1949 query.beginGroup(); 1950 query.isNotNull("$.name"); 1951 query.endGroup(); 1952 expect(query.getSqlLike() !== "").assertTrue(); 1953 console.info("query is " + query.getSqlLike()); 1954 } catch (e) { 1955 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1956 expect(null).assertFail(); 1957 } 1958 query = null; 1959 done(); 1960 }) 1961 1962 /** 1963 * @tc.name QueryBeginGroupTest002 1964 * @tc.desc Test Js Api Query.BeginGroup() testcase 002 1965 * @tc.type: FUNC 1966 * @tc.require: issueNumber 1967 */ 1968 it('QueryBeginGroupTest002', 0, async function(done) { 1969 var query = null; 1970 try { 1971 query = new ddm.Query(); 1972 expect("").assertEqual(query.getSqlLike()); 1973 query.beginGroup(); 1974 query.beginGroup(); 1975 query.notEqualTo("$.name", 0); 1976 query.endGroup(); 1977 query.beginGroup(); 1978 expect(query.getSqlLike() !== "").assertTrue(); 1979 console.info("query is " + query.getSqlLike()); 1980 } catch (e) { 1981 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 1982 expect(null).assertFail(); 1983 } 1984 query = null; 1985 done(); 1986 }) 1987 1988 /** 1989 * @tc.name QueryBeginGroupTest003 1990 * @tc.desc Test Js Api Query.BeginGroup() testcase 003 1991 * @tc.type: FUNC 1992 * @tc.require: issueNumber 1993 */ 1994 it('QueryBeginGroupTest003', 0, async function(done) { 1995 var query = null; 1996 try { 1997 query = new ddm.Query(); 1998 expect("").assertEqual(query.getSqlLike()); 1999 query.beginGroup(1); 2000 console.info("should throw exception on invalid arguments"); 2001 expect(null).assertFail(); 2002 } catch (e) { 2003 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2004 } 2005 query = null; 2006 done(); 2007 }) 2008 2009 /** 2010 * @tc.name QueryBeginGroupTest004 2011 * @tc.desc Test Js Api Query.BeginGroup() testcase 004 2012 * @tc.type: FUNC 2013 * @tc.require: issueNumber 2014 */ 2015 it('QueryBeginGroupTest004', 0, async function(done) { 2016 var query = null; 2017 try { 2018 query = new ddm.Query(); 2019 expect("").assertEqual(query.getSqlLike()); 2020 query.beginGroup("any", 1); 2021 console.info("should throw exception on invalid arguments"); 2022 expect(null).assertFail(); 2023 } catch (e) { 2024 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2025 } 2026 query = null; 2027 done(); 2028 }) 2029 2030 /** 2031 * @tc.name QueryEndGroupTest001 2032 * @tc.desc Test Js Api Query.EndGroup() testcase 001 2033 * @tc.type: FUNC 2034 * @tc.require: issueNumber 2035 */ 2036 it('QueryEndGroupTest001', 0, async function(done) { 2037 var query = null; 2038 try { 2039 query = new ddm.Query(); 2040 expect("").assertEqual(query.getSqlLike()); 2041 query.beginGroup(); 2042 query.isNotNull("$.name"); 2043 query.endGroup(); 2044 expect(query.getSqlLike() !== "").assertTrue(); 2045 console.info("query is " + query.getSqlLike()); 2046 } catch (e) { 2047 expect(null).assertFail(); 2048 } 2049 query = null; 2050 done(); 2051 }) 2052 2053 /** 2054 * @tc.name QueryEndGroupTest002 2055 * @tc.desc Test Js Api Query.EndGroup() testcase 002 2056 * @tc.type: FUNC 2057 * @tc.require: issueNumber 2058 */ 2059 it('QueryEndGroupTest002', 0, async function(done) { 2060 var query = null; 2061 try { 2062 query = new ddm.Query(); 2063 expect("").assertEqual(query.getSqlLike()); 2064 query.endGroup(); 2065 query.beginGroup(); 2066 query.isNotNull("$.name"); 2067 query.endGroup(); 2068 expect(query.getSqlLike() !== "").assertTrue(); 2069 console.info("query is " + query.getSqlLike()); 2070 } catch (e) { 2071 expect(null).assertFail(); 2072 } 2073 query = null; 2074 done(); 2075 }) 2076 2077 /** 2078 * @tc.name QueryEndGroupTest003 2079 * @tc.desc Test Js Api Query.EndGroup() testcase 003 2080 * @tc.type: FUNC 2081 * @tc.require: issueNumber 2082 */ 2083 it('QueryEndGroupTest003', 0, async function(done) { 2084 var query = null; 2085 try { 2086 query = new ddm.Query(); 2087 expect("").assertEqual(query.getSqlLike()); 2088 query.endGroup(0); 2089 console.info("should throw exception on invalid arguments"); 2090 expect(null).assertFail(); 2091 } catch (e) { 2092 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2093 } 2094 query = null; 2095 done(); 2096 }) 2097 2098 /** 2099 * @tc.name QueryEndGroupTest004 2100 * @tc.desc Test Js Api Query.EndGroup() testcase 004 2101 * @tc.type: FUNC 2102 * @tc.require: issueNumber 2103 */ 2104 it('QueryEndGroupTest004', 0, async function(done) { 2105 var query = null; 2106 try { 2107 query = new ddm.Query(); 2108 expect("").assertEqual(query.getSqlLike()); 2109 query.endGroup("any"); 2110 console.info("should throw exception on invalid arguments"); 2111 expect(null).assertFail(); 2112 } catch (e) { 2113 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2114 } 2115 query = null; 2116 done(); 2117 }) 2118 2119 /** 2120 * @tc.name QueryPrefixKeyTest001 2121 * @tc.desc Test Js Api Query.PrefixKey() testcase 001 2122 * @tc.type: FUNC 2123 * @tc.require: issueNumber 2124 */ 2125 it('QueryPrefixKeyTest001', 0, async function(done) { 2126 var query = null; 2127 try { 2128 query = new ddm.Query(); 2129 expect("").assertEqual(query.getSqlLike()); 2130 query.prefixKey("$.name"); 2131 query.prefixKey("0"); 2132 expect(query.getSqlLike() !== "").assertTrue(); 2133 console.info("query is " + query.getSqlLike()); 2134 } catch (e) { 2135 expect(null).assertFail(); 2136 } 2137 query = null; 2138 done(); 2139 }) 2140 2141 /** 2142 * @tc.name QueryPrefixKeyTest002 2143 * @tc.desc Test Js Api Query.PrefixKey() testcase 002 2144 * @tc.type: FUNC 2145 * @tc.require: issueNumber 2146 */ 2147 it('QueryPrefixKeyTest002', 0, async function(done) { 2148 var query = null; 2149 try { 2150 query = new ddm.Query(); 2151 expect("").assertEqual(query.getSqlLike()); 2152 query.prefixKey("kx1").or().prefixKey("kx2").or().prefixKey("kx3"); 2153 expect(query.getSqlLike() !== "").assertTrue(); 2154 console.info("query is " + query.getSqlLike()); 2155 } catch (e) { 2156 expect(null).assertFail(); 2157 } 2158 query = null; 2159 done(); 2160 }) 2161 2162 /** 2163 * @tc.name QueryPrefixKeyTest003 2164 * @tc.desc Test Js Api Query.PrefixKey() testcase 003 2165 * @tc.type: FUNC 2166 * @tc.require: issueNumber 2167 */ 2168 it('QueryPrefixKeyTest003', 0, async function(done) { 2169 var query = null; 2170 try { 2171 query = new ddm.Query(); 2172 expect("").assertEqual(query.getSqlLike()); 2173 query.prefixKey("k", "any"); 2174 console.info("should throw exception on invalid arguments"); 2175 expect(null).assertFail(); 2176 } catch (e) { 2177 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2178 } 2179 query = null; 2180 done(); 2181 }) 2182 2183 /** 2184 * @tc.name QueryPrefixKeyTest004 2185 * @tc.desc Test Js Api Query.PrefixKey() testcase 004 2186 * @tc.type: FUNC 2187 * @tc.require: issueNumber 2188 */ 2189 it('QueryPrefixKeyTest004', 0, async function(done) { 2190 var query = null; 2191 try { 2192 query = new ddm.Query(); 2193 expect("").assertEqual(query.getSqlLike()); 2194 query.prefixKey(123); 2195 console.info("should throw exception on invalid arguments"); 2196 expect(null).assertFail(); 2197 } catch (e) { 2198 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2199 } 2200 query = null; 2201 done(); 2202 }) 2203 2204 /** 2205 * @tc.name QuerySetSuggestIndexTest001 2206 * @tc.desc Test Js Api Query.SetSuggestIndex() testcase 001 2207 * @tc.type: FUNC 2208 * @tc.require: issueNumber 2209 */ 2210 it('QuerySetSuggestIndexTest001', 0, async function(done) { 2211 var query = null; 2212 try { 2213 query = new ddm.Query(); 2214 expect("").assertEqual(query.getSqlLike()); 2215 query.setSuggestIndex("$.name"); 2216 query.setSuggestIndex("0"); 2217 expect(query.getSqlLike() !== "").assertTrue(); 2218 console.info("query is " + query.getSqlLike()); 2219 } catch (e) { 2220 expect(null).assertFail(); 2221 } 2222 query = null; 2223 done(); 2224 }) 2225 2226 /** 2227 * @tc.name QuerySetSuggestIndexTest002 2228 * @tc.desc Test Js Api Query.SetSuggestIndex() testcase 002 2229 * @tc.type: FUNC 2230 * @tc.require: issueNumber 2231 */ 2232 it('QuerySetSuggestIndexTest002', 0, async function(done) { 2233 var query = null; 2234 try { 2235 query = new ddm.Query(); 2236 expect("").assertEqual(query.getSqlLike()); 2237 query.setSuggestIndex("kxx").or().equalTo("key2", "v1"); 2238 expect(query.getSqlLike() !== "").assertTrue(); 2239 console.info("query is " + query.getSqlLike()); 2240 } catch (e) { 2241 expect(null).assertFail(); 2242 } 2243 query = null; 2244 done(); 2245 }) 2246 2247 /** 2248 * @tc.name QuerySetSuggestIndexTest003 2249 * @tc.desc Test Js Api Query.SetSuggestIndex() testcase 003 2250 * @tc.type: FUNC 2251 * @tc.require: issueNumber 2252 */ 2253 it('QuerySetSuggestIndexTest003', 0, async function(done) { 2254 var query = null; 2255 try { 2256 query = new ddm.Query(); 2257 expect("").assertEqual(query.getSqlLike()); 2258 query.setSuggestIndex("k", "any"); 2259 console.info("should throw exception on invalid arguments"); 2260 expect(null).assertFail(); 2261 } catch (e) { 2262 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2263 } 2264 query = null; 2265 done(); 2266 }) 2267 2268 /** 2269 * @tc.name QuerySetSuggestIndexTest004 2270 * @tc.desc Test Js Api Query.SetSuggestIndex() testcase 004 2271 * @tc.type: FUNC 2272 * @tc.require: issueNumber 2273 */ 2274 it('QuerySetSuggestIndexTest004', 0, async function(done) { 2275 var query = null; 2276 try { 2277 query = new ddm.Query(); 2278 expect("").assertEqual(query.getSqlLike()); 2279 query.setSuggestIndex(123); 2280 console.info("should throw exception on invalid arguments"); 2281 expect(null).assertFail(); 2282 } catch (e) { 2283 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2284 } 2285 query = null; 2286 done(); 2287 }) 2288 2289 /** 2290 * @tc.name QueryDeviceIdTest001 2291 * @tc.desc Test Js Api Query.DeviceId() testcase 001 2292 * @tc.type: FUNC 2293 * @tc.require: issueNumber 2294 */ 2295 it('QueryDeviceIdTest001', 0, async function(done) { 2296 var query = null; 2297 try { 2298 query = new ddm.Query(); 2299 expect("").assertEqual(query.getSqlLike()); 2300 query.deviceId("$.name"); 2301 query.deviceId("0"); 2302 expect(query.getSqlLike() !== "").assertTrue(); 2303 console.info("query is " + query.getSqlLike()); 2304 } catch (e) { 2305 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 2306 expect(null).assertFail(); 2307 } 2308 query = null; 2309 done(); 2310 }) 2311 2312 /** 2313 * @tc.name QueryDeviceIdTest002 2314 * @tc.desc Test Js Api Query.DeviceId() testcase 002 2315 * @tc.type: FUNC 2316 * @tc.require: issueNumber 2317 */ 2318 it('QueryDeviceIdTest002', 0, async function(done) { 2319 var query = null; 2320 try { 2321 query = new ddm.Query(); 2322 expect("").assertEqual(query.getSqlLike()); 2323 query.deviceId("kxx").equalTo("key2", "v1"); 2324 expect(query.getSqlLike() !== "").assertTrue(); 2325 console.info("query is " + query.getSqlLike()); 2326 } catch (e) { 2327 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 2328 expect(null).assertFail(); 2329 } 2330 query = null; 2331 done(); 2332 }) 2333 2334 /** 2335 * @tc.name QueryDeviceIdTest003 2336 * @tc.desc Test Js Api Query.DeviceId() testcase 003 2337 * @tc.type: FUNC 2338 * @tc.require: issueNumber 2339 */ 2340 it('QueryDeviceIdTest003', 0, async function(done) { 2341 var query = null; 2342 try { 2343 query = new ddm.Query(); 2344 expect("").assertEqual(query.getSqlLike()); 2345 query.deviceId("k", "any"); 2346 console.info("should throw exception on invalid arguments"); 2347 expect(null).assertFail(); 2348 } catch (e) { 2349 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2350 } 2351 query = null; 2352 done(); 2353 }) 2354 2355 /** 2356 * @tc.name QueryDeviceIdTest004 2357 * @tc.desc Test Js Api Query.DeviceId() testcase 004 2358 * @tc.type: FUNC 2359 * @tc.require: issueNumber 2360 */ 2361 it('QueryDeviceIdTest004', 0, async function(done) { 2362 var query = null; 2363 try { 2364 query = new ddm.Query(); 2365 expect("").assertEqual(query.getSqlLike()); 2366 query.deviceId(123); 2367 console.info("should throw exception on invalid arguments"); 2368 expect(null).assertFail(); 2369 } catch (e) { 2370 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2371 } 2372 query = null; 2373 done(); 2374 }) 2375 2376 /** 2377 * @tc.name QueryGetSqlLikeTest001 2378 * @tc.desc Test Js Api Query.GetSqlLike() testcase 001 2379 * @tc.type: FUNC 2380 * @tc.require: issueNumber 2381 */ 2382 it('QueryGetSqlLikeTest001', 0, async function(done) { 2383 var query = null; 2384 try { 2385 query = new ddm.Query(); 2386 expect("").assertEqual(query.getSqlLike()); 2387 let sql1 = query.getSqlLike(); 2388 console.info("testGetSqlLike001 sql=" + sql1); 2389 let sql2 = query.getSqlLike(); 2390 expect(sql1).assertEqual(sql2); 2391 console.info("query is " + query.getSqlLike()); 2392 } catch (e) { 2393 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 2394 expect(null).assertFail(); 2395 } 2396 query = null; 2397 done(); 2398 }) 2399 2400 /** 2401 * @tc.name QueryGetSqlLikeTest002 2402 * @tc.desc Test Js Api Query.GetSqlLike() testcase 002 2403 * @tc.type: FUNC 2404 * @tc.require: issueNumber 2405 */ 2406 it('QueryGetSqlLikeTest002', 0, async function(done) { 2407 var query = null; 2408 try { 2409 query = new ddm.Query(); 2410 expect("").assertEqual(query.getSqlLike()); 2411 let sql1 = query.getSqlLike(); 2412 console.info("testGetSqlLike002 sql=" + sql1); 2413 query.inString("key1", ["AAA", "BBB"]) 2414 .or() 2415 .notEqualTo("key2", 0); 2416 let sql2 = query.getSqlLike(); 2417 console.info("testGetSqlLike002 sql=" + sql2); 2418 console.info("query is " + query.getSqlLike()); 2419 expect(sql1 !== sql2).assertTrue(); 2420 } catch (e) { 2421 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 2422 expect(null).assertFail(); 2423 } 2424 query = null; 2425 done(); 2426 }) 2427 2428 /** 2429 * @tc.name QueryGetSqlLikeTest003 2430 * @tc.desc Test Js Api Query.GetSqlLike() testcase 003 2431 * @tc.type: FUNC 2432 * @tc.require: issueNumber 2433 */ 2434 it('QueryGetSqlLikeTest003', 0, async function(done) { 2435 var query = null; 2436 try { 2437 query = new ddm.Query(); 2438 expect("").assertEqual(query.getSqlLike()); 2439 query.inNumber("key"); 2440 query.getSqlLike(0); 2441 console.info("should throw exception on invalid arguments"); 2442 expect(null).assertFail(); 2443 } catch (e) { 2444 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2445 } 2446 query = null; 2447 done(); 2448 }) 2449 2450 /** 2451 * @tc.name QueryGetSqlLikeTest004 2452 * @tc.desc Test Js Api Query.GetSqlLike() testcase 004 2453 * @tc.type: FUNC 2454 * @tc.require: issueNumber 2455 */ 2456 it('QueryGetSqlLikeTest004', 0, async function(done) { 2457 var query = null; 2458 try { 2459 query = new ddm.Query(); 2460 expect("").assertEqual(query.getSqlLike()); 2461 query.inNumber("key"); 2462 query.getSqlLike("any"); 2463 console.info("should throw exception on invalid arguments"); 2464 expect(null).assertFail(); 2465 } catch (e) { 2466 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 2467 } 2468 query = null; 2469 done(); 2470 }) 2471}) 2472