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 */ 15 16import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' 17import ddm from '@ohos.data.distributedKVStore'; 18 19describe('queryTest', function () { 20 21 /** 22 * @tc.name: QueryResetSucTest 23 * @tc.desc: Test Js Api Query.reset() successfully 24 * @tc.type: FUNC 25 * @tc.require: issueNumber 26 */ 27 it('QueryResetSucTest', 0, async function (done) { 28 var query = null; 29 try { 30 query = new ddm.Query(); 31 expect("").assertEqual(query.getSqlLike()); 32 query.equalTo("number", 5); 33 query.equalTo("string", 'v'); 34 query.equalTo("boolean", false); 35 console.info("query is " + query.getSqlLike()); 36 expect(query.getSqlLike() !== "").assertTrue(); 37 query.reset(); 38 expect("").assertEqual(query.getSqlLike()); 39 console.info("sql after reset: " + query.getSqlLike()); 40 console.info("query is " + query.getSqlLike()); 41 } catch (e) { 42 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 43 expect(null).assertFail(); 44 } 45 query = null; 46 done(); 47 }) 48 49 /** 50 * @tc.name: QueryResetCalAfterResetTest 51 * @tc.desc: Test Js Api Query.reset() call after reset successfully 52 * @tc.type: FUNC 53 * @tc.require: issueNumber 54 */ 55 it('QueryResetCalAfterResetTest', 0, async function (done) { 56 var query = null; 57 try { 58 query = new ddm.Query(); 59 expect("").assertEqual(query.getSqlLike()); 60 query.equalTo("key", "value"); 61 expect(query.getSqlLike() !== "").assertTrue(); 62 let sql = query.getSqlLike(); 63 query.reset().equalTo("key", "value"); 64 console.info("query is " + query.getSqlLike()); 65 expect(sql === query.getSqlLike()).assertTrue(); 66 } catch (e) { 67 console.error("should be ok on Method Chaining : " + `, error code is ${e.code}, message is ${e.message}`); 68 expect(null).assertFail(); 69 } 70 query = null; 71 done(); 72 }) 73 74 /** 75 * @tc.name: QueryResetInvalidArgumentsTest 76 * @tc.desc: Test Js Api Query.reset() with invalid arguments 77 * @tc.type: FUNC 78 * @tc.require: issueNumber 79 */ 80 it('QueryResetInvalidArgumentsTest', 0, async function (done) { 81 var query = null; 82 try { 83 query = new ddm.Query(); 84 expect("").assertEqual(query.getSqlLike()); 85 query.equalTo("key", "value"); 86 expect(query.getSqlLike() !== "").assertTrue(); 87 query.reset(3); 88 console.info("should throw exception on invalid arguments"); 89 expect(null).assertFail(); 90 } catch (e) { 91 console.log("throw exception is ok"); 92 expect(true).assertTrue(); 93 } 94 query = null; 95 done(); 96 }) 97 98 /** 99 * @tc.name: QueryEqualToSucTest 100 * @tc.desc: Test Js Api Query.equalTo() successfully 101 * @tc.type: FUNC 102 * @tc.require: issueNumber 103 */ 104 it('QueryEqualToSucTest', 0, async function (done) { 105 var query = null; 106 try { 107 query = new ddm.Query(); 108 expect("").assertEqual(query.getSqlLike()); 109 query.equalTo("key1", 5); 110 query.equalTo("key2", 5.0); 111 query.equalTo("key3", false); 112 query.equalTo("key3", "string"); 113 expect(query.getSqlLike() !== "").assertTrue(); 114 console.info("query is " + query.getSqlLike()); 115 } catch (e) { 116 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 117 expect(null).assertFail(); 118 } 119 query = null; 120 done(); 121 }) 122 123 /** 124 * @tc.name: QueryEqualToNanTest 125 * @tc.desc: Test Js Api Query.equalTo() with value Nan 126 * @tc.type: FUNC 127 * @tc.require: issueNumber 128 */ 129 it('QueryEqualToNanTest', 0, async function (done) { 130 var query = null; 131 try { 132 query = new ddm.Query(); 133 expect("").assertEqual(query.getSqlLike()); 134 query.equalTo("key2", NaN); 135 expect(query.getSqlLike() !== "").assertTrue(); 136 console.info("query is " + query.getSqlLike()); 137 } catch (e) { 138 expect(null).assertFail(); 139 } 140 query = null; 141 done(); 142 }) 143 144 /** 145 * @tc.name: QueryEqualToInvalidMoreArgTest 146 * @tc.desc: Test Js Api Query.equalTo() with invalid more arguments 147 * @tc.type: FUNC 148 * @tc.require: issueNumber 149 */ 150 it('QueryEqualToInvalidArgTest', 0, async function (done) { 151 var query = null; 152 try { 153 query = new ddm.Query(); 154 expect("").assertEqual(query.getSqlLike()); 155 query.equalTo("key1", "value", "too more"); 156 console.info("should not throw exception on invalid arguments"); 157 expect(query.getSqlLike() !== "").assertTrue(); 158 } catch (e) { 159 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 160 expect(null).assertFail(); 161 } 162 query = null; 163 done(); 164 }) 165 166 /** 167 * @tc.name: QueryEqualToInvalidLessArgTest 168 * @tc.desc: Test Js Api Query.equalTo() with invalid less arguments 169 * @tc.type: FUNC 170 * @tc.require: issueNumber 171 */ 172 it('QueryEqualToInvalidArgTest', 0, async function (done) { 173 var query = null; 174 try { 175 query = new ddm.Query(); 176 expect("").assertEqual(query.getSqlLike()); 177 query.equalTo(); 178 expect(null).assertFail(); 179 } catch (e) { 180 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 181 expect(e.code == 401).assertTrue(); 182 } 183 query = null; 184 done(); 185 }) 186 187 /** 188 * @tc.name: QueryNotEqualToSucTest 189 * @tc.desc: Test Js Api Query.notEualTo() successfully 190 * @tc.type: FUNC 191 * @tc.require: issueNumber 192 */ 193 it('QueryNotEqualToSucTest', 0, async function (done) { 194 var query = null; 195 try { 196 query = new ddm.Query(); 197 expect("").assertEqual(query.getSqlLike()); 198 query.notEqualTo("key1", 5); 199 query.notEqualTo("key2", 5.0); 200 query.notEqualTo("key3", false); 201 query.notEqualTo("key4", "string"); 202 expect(query.getSqlLike() !== "").assertTrue(); 203 } catch (e) { 204 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 205 expect(null).assertFail(); 206 } 207 query = null; 208 done(); 209 }) 210 211 /** 212 * @tc.name: QueryNotEqualToNanTest 213 * @tc.desc: Test Js Api Query.equalTo() with nan values 214 * @tc.type: FUNC 215 * @tc.require: issueNumber 216 */ 217 it('QueryNotEqualToNanTest', 0, async function (done) { 218 var query = null; 219 try { 220 query = new ddm.Query(); 221 expect("").assertEqual(query.getSqlLike()); 222 query.notEqualTo("key2", NaN); 223 expect(query.getSqlLike() !== "").assertTrue(); 224 } catch (e) { 225 expect(null).assertFail(); 226 } 227 query = null; 228 done(); 229 }) 230 231 /** 232 * @tc.name: QueryNotEqualToInvalidMoreArgTest 233 * @tc.desc: Test Js Api Query.equalTo() with invalid more arguments 234 * @tc.type: FUNC 235 * @tc.require: issueNumber 236 */ 237 it('QueryNotEqualToInvalidMoreArgTest', 0, async function (done) { 238 var query = null; 239 try { 240 query = new ddm.Query(); 241 expect("").assertEqual(query.getSqlLike()); 242 query.notEqualTo("key1", "value", "too more", 4); 243 console.info("should not throw exception on invalid arguments"); 244 expect(true).assertTrue(); 245 } catch (e) { 246 console.log("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 247 expect(null).assertFail(); 248 } 249 query = null; 250 done(); 251 }) 252 253 /** 254 * @tc.name: QueryNotEqualToInvalidLessArgTest 255 * @tc.desc: Test Js Api Query.equalTo() with invalid less arguments 256 * @tc.type: FUNC 257 * @tc.require: issueNumber 258 */ 259 it('QueryNotEqualToInvalidLessArgTest', 0, async function (done) { 260 var query = null; 261 try { 262 query = new ddm.Query(); 263 expect("").assertEqual(query.getSqlLike()); 264 query.notEqualTo(); 265 console.info("should throw exception on invalid arguments"); 266 expect(null).assertFail(); 267 } catch (e) { 268 console.log("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 269 expect(e.code == 401).assertTrue(); 270 } 271 query = null; 272 done(); 273 }) 274 275 /** 276 * @tc.name: QueryGreaterThanSucTest 277 * @tc.desc: Test Js Api Query.greaterThan() successfully 278 * @tc.type: FUNC 279 * @tc.require: issueNumber 280 */ 281 it('QueryGreaterThanSucTest', 0, async function (done) { 282 var query = null; 283 try { 284 query = new ddm.Query(); 285 expect("").assertEqual(query.getSqlLike()); 286 query.greaterThan("key1", 5); 287 query.greaterThan("key2", 5.0); 288 query.greaterThan("key3", true); 289 query.greaterThan("key4", "string"); 290 expect(query.getSqlLike() !== "").assertTrue(); 291 console.info("query is " + query.getSqlLike()); 292 } catch (e) { 293 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 294 expect(null).assertFail(); 295 } 296 query = null; 297 done(); 298 }) 299 300 /** 301 * @tc.name: QueryGreatThanNanTest 302 * @tc.desc: Test Js Api Query.GreatThan() with value nan 303 * @tc.type: FUNC 304 * @tc.require: issueNumber 305 */ 306 it('QueryGreatThanNanTest', 0, async function (done) { 307 var query = null; 308 try { 309 query = new ddm.Query(); 310 expect("").assertEqual(query.getSqlLike()); 311 query.greaterThan("key2", NaN); 312 console.info("should not throw exception on invalid arguments"); 313 expect(true).assertTrue(); 314 } catch (e) { 315 expect(null).assertFail(); 316 } 317 query = null; 318 done(); 319 }) 320 321 /** 322 * @tc.name: QueryGreatThanInvalidMoreArgsTest 323 * @tc.desc: Test Js Api Query.GreatThan() with invalid more arguments 324 * @tc.type: FUNC 325 * @tc.require: issueNumber 326 **/ 327 it('QueryGreatThanInvalidMoreArgsTest', 0, async function (done) { 328 var query = null; 329 try { 330 query = new ddm.Query(); 331 expect("").assertEqual(query.getSqlLike()); 332 query.greaterThan("key1", "value", "too more", 4); 333 console.info("should not throw exception on invalid arguments"); 334 expect(query.getSqlLike() !== "").assertTrue(); 335 } catch (e) { 336 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 337 expect(null).assertFail(); 338 } 339 query = null; 340 done(); 341 }) 342 343 /** 344 * @tc.name: QueryGreatThanInvalidLessArgsTest 345 * @tc.desc: Test Js Api Query.GreatThan() with invalid less arguments 346 * @tc.type: FUNC 347 * @tc.require: issueNumber 348 **/ 349 it('QueryGreatThanInvalidLessArgsTest', 0, async function (done) { 350 var query = null; 351 try { 352 query = new ddm.Query(); 353 expect("").assertEqual(query.getSqlLike()); 354 query.greaterThan(); 355 console.info("should throw exception on invalid arguments"); 356 expect(null).assertFail(); 357 } catch (e) { 358 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 359 expect(e.code == 401).assertTrue(); 360 } 361 query = null; 362 done(); 363 }) 364 365 /** 366 * @tc.name: QueryLessThanSucTest 367 * @tc.desc: Test Js Api Query.LessThan() successfully 368 * @tc.type: FUNC 369 * @tc.require: issueNumber 370 */ 371 it('QueryLessThanSucTest', 0, async function (done) { 372 var query = null; 373 try { 374 query = new ddm.Query(); 375 expect("").assertEqual(query.getSqlLike()); 376 query.lessThan("key1", 5); 377 query.lessThan("key2", 5.0); 378 query.lessThan("key3", true); 379 query.lessThan("key4", "string"); 380 expect(query.getSqlLike() !== "").assertTrue(); 381 } catch (e) { 382 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 383 expect(null).assertFail(); 384 } 385 query = null; 386 done(); 387 }) 388 389 /** 390 * @tc.name: QueryLessThanNanTest 391 * @tc.desc: Test Js Api Query.LessThan() with value nan 392 * @tc.type: FUNC 393 * @tc.require: issueNumber 394 */ 395 it('QueryLessThanNanTest', 0, async function (done) { 396 var query = null; 397 try { 398 query = new ddm.Query(); 399 expect("").assertEqual(query.getSqlLike()); 400 query.lessThan("key2", NaN); 401 console.info("query is " + query.getSqlLike()); 402 expect(true).assertTrue(); 403 } catch (e) { 404 expect(null).assertFail(); 405 } 406 query = null; 407 done(); 408 }) 409 410 /** 411 * @tc.name: QueryLessThanInvalidMoreArgsTest 412 * @tc.desc: Test Js Api Query.LessThan() with invalid more arguments 413 * @tc.type: FUNC 414 * @tc.require: issueNumber 415 */ 416 it('QueryLessThanInvalidMoreArgsTest', 0, async function (done) { 417 var query = null; 418 try { 419 query = new ddm.Query(); 420 expect("").assertEqual(query.getSqlLike()); 421 query.lessThan("key1", "value", "too more", 4); 422 console.info("query is " + query.getSqlLike()); 423 expect(query.getSqlLike() !== "").assertTrue(); 424 } catch (e) { 425 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 426 expect(null).assertFail(); 427 } 428 query = null; 429 done(); 430 }) 431 432 /** 433 * @tc.name: QueryLessThanInvalidLessArgsTest 434 * @tc.desc: Test Js Api Query.LessThan() with invalid less arguments 435 * @tc.type: FUNC 436 * @tc.require: issueNumber 437 */ 438 it('QueryLessThanInvalidLessArgsTest', 0, async function (done) { 439 var query = null; 440 try { 441 query = new ddm.Query(); 442 expect("").assertEqual(query.getSqlLike()); 443 query.lessThan(); 444 console.info("query is " + query.getSqlLike()); 445 expect(null).assertFail(); 446 } catch (e) { 447 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 448 expect(e.code == 401).assertTrue(); 449 } 450 query = null; 451 done(); 452 }) 453 454 /** 455 * @tc.name: QueryGreaterThanOrEqualToSucTest 456 * @tc.desc: Test Js Api Query.GreaterThanOrEqualTo() successfully 457 * @tc.type: FUNC 458 * @tc.require: issueNumber 459 */ 460 it('QueryGreaterThanOrEqualToSucTest', 0, async function (done) { 461 var query = null; 462 try { 463 query = new ddm.Query(); 464 expect("").assertEqual(query.getSqlLike()); 465 query.greaterThanOrEqualTo("key1", 5); 466 query.greaterThanOrEqualTo("key2", 5.0); 467 query.greaterThanOrEqualTo("key3", true); 468 query.greaterThanOrEqualTo("key4", "string"); 469 expect(query.getSqlLike() !== "").assertTrue(); 470 console.info("query is " + query.getSqlLike()); 471 } catch (e) { 472 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 473 expect(null).assertFail(); 474 } 475 query = null; 476 done(); 477 }) 478 479 /** 480 * @tc.name: QueryGreaterThanOrEqualToNanTest 481 * @tc.desc: Test Js Api Query.GreaterThanOrEqualTo() with value nan 482 * @tc.type: FUNC 483 * @tc.require: issueNumber 484 */ 485 it('QueryGreaterThanOrEqualToNanTest', 0, async function (done) { 486 var query = null; 487 try { 488 query = new ddm.Query(); 489 expect("").assertEqual(query.getSqlLike()); 490 query.greaterThanOrEqualTo("key2", NaN); 491 expect(query.getSqlLike() !== "").assertTrue(); 492 } catch (e) { 493 console.error(`failed, error code is ${e.code}, message is ${e.message}`); 494 expect(null).assertFail(); 495 } 496 query = null; 497 done(); 498 }) 499 500 /** 501 * @tc.name: QueryGreaterThanOrEqualToInvalidMoreArgsTest 502 * @tc.desc: Test Js Api Query.GreaterThanOrEqualTo() with invalid more arguments 503 * @tc.type: FUNC 504 * @tc.require: issueNumber 505 */ 506 it('QueryGreaterThanOrEqualToInvalidMoreArgsTest', 0, async function (done) { 507 var query = null; 508 try { 509 query = new ddm.Query(); 510 expect("").assertEqual(query.getSqlLike()); 511 query.greaterThanOrEqualTo("key1", "value", "too more", 4); 512 console.info("should not throw exception on invalid arguments"); 513 expect(query.getSqlLike() !== "").assertTrue(); 514 } catch (e) { 515 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 516 expect(null).assertFail(); 517 } 518 query = null; 519 done(); 520 }) 521 522 /** 523 * @tc.name: QueryGreaterThanOrEqualToInvalidLessArgsTest 524 * @tc.desc: Test Js Api Query.GreaterThanOrEqualTo() with invalid less arguments 525 * @tc.type: FUNC 526 * @tc.require: issueNumber 527 */ 528 it('QueryGreaterThanOrEqualToInvalidLessArgsTest', 0, async function (done) { 529 var query = null; 530 try { 531 query = new ddm.Query(); 532 expect("").assertEqual(query.getSqlLike()); 533 query.greaterThanOrEqualTo(); 534 console.info("should not throw exception on invalid arguments"); 535 expect(null).assertFail(); 536 } catch (e) { 537 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 538 expect(e.code == 401).assertTrue(); 539 } 540 query = null; 541 done(); 542 }) 543 544 /** 545 * @tc.name: QueryLessThanOrEqualToSucTest 546 * @tc.desc: Test Js Api Query.LessThanOrEqualTo() successfully 547 * @tc.type: FUNC 548 * @tc.require: issueNumber 549 */ 550 it('QueryLessThanOrEqualToSucTest', 0, async function (done) { 551 var query = null; 552 try { 553 query = new ddm.Query(); 554 expect("").assertEqual(query.getSqlLike()); 555 query.lessThanOrEqualTo("key1", 5); 556 query.lessThanOrEqualTo("key2", 5.0); 557 query.lessThanOrEqualTo("key3", true); 558 query.lessThanOrEqualTo("key4", "string"); 559 expect(query.getSqlLike() !== "").assertTrue(); 560 console.info("query is " + query.getSqlLike()); 561 } catch (e) { 562 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 563 expect(null).assertFail(); 564 } 565 query = null; 566 done(); 567 }) 568 569 /** 570 * @tc.name: QueryLessThanOrEqualToNanTest 571 * @tc.desc: Test Js Api Query.LessThanOrEqualTo() with value nan 572 * @tc.type: FUNC 573 * @tc.require: issueNumber 574 */ 575 it('QueryLessThanOrEqualToNanTest', 0, async function (done) { 576 var query = null; 577 try { 578 query = new ddm.Query(); 579 expect("").assertEqual(query.getSqlLike()); 580 query.lessThanOrEqualTo("key2", NaN); 581 console.info("query is " + query.getSqlLike()); 582 expect(true).assertTrue(); 583 } catch (e) { 584 expect(null).assertFail(); 585 } 586 query = null; 587 done(); 588 }) 589 590 /** 591 * @tc.name: QueryLessThanOrEqualToInvalidMoreArgsTest 592 * @tc.desc: Test Js Api Query.LessThanOrEqualTo() with invalid more args 593 * @tc.type: FUNC 594 * @tc.require: issueNumber 595 */ 596 it('nameQueryLessThanOrEqualToInvalidMoreArgsTest', 0, async function (done) { 597 var query = null; 598 try { 599 query = new ddm.Query(); 600 expect("").assertEqual(query.getSqlLike()); 601 query.lessThanOrEqualTo("key1", "value", "too more", 4); 602 console.info("should not throw exception on invalid arguments"); 603 expect(query.getSqlLike() !== "").assertTrue(); 604 } catch (e) { 605 console.error("throw exception: " + `, error code is ${e.code}, message is ${e.message}`); 606 expect(null).assertFail(); 607 } 608 query = null; 609 done(); 610 }) 611 612 /** 613 * @tc.name: QueryLessThanOrEqualToInvalidLessArgsTest 614 * @tc.desc: Test Js Api Query.LessThanOrEqualTo() with invalid less args 615 * @tc.type: FUNC 616 * @tc.require: issueNumber 617 */ 618 it('QueryLessThanOrEqualToInvalidLessArgsTest', 0, async function (done) { 619 var query = null; 620 try { 621 query = new ddm.Query(); 622 expect("").assertEqual(query.getSqlLike()); 623 query.lessThanOrEqualTo(); 624 console.info("should not throw exception on invalid arguments"); 625 expect(null).assertFail(); 626 } catch (e) { 627 console.error("throw exception: " + `, error code is ${e.code}, message is ${e.message}`); 628 expect(e.code == 401).assertTrue(); 629 } 630 query = null; 631 done(); 632 }) 633 634 /** 635 * @tc.name: QueryIsNullSucTest 636 * @tc.desc: Test Js Api Query.IsNull() successfully 637 * @tc.type: FUNC 638 * @tc.require: issueNumber 639 */ 640 it('QueryIsNullSucTest', 0, async function (done) { 641 var query = null; 642 try { 643 query = new ddm.Query(); 644 expect("").assertEqual(query.getSqlLike()); 645 query.isNull("key"); 646 query.isNull("key2"); 647 expect(query.getSqlLike() !== "").assertTrue(); 648 console.info("query is " + query.getSqlLike()); 649 } catch (e) { 650 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 651 expect(null).assertFail(); 652 } 653 query = null; 654 done(); 655 }) 656 657 /** 658 * @tc.name: QueryIsNullInvalidMoreArgsTest 659 * @tc.desc: Test Js Api Query.IsNull() with invalid more args 660 * @tc.type: FUNC 661 * @tc.require: issueNumber 662 */ 663 it('QueryIsNullInvalidMoreArgsTest', 0, async function (done) { 664 var query = null; 665 try { 666 query = new ddm.Query(); 667 expect("").assertEqual(query.getSqlLike()); 668 query.isNull("key", 0); 669 console.info("should not throw exception on invalid arguments"); 670 expect(query.getSqlLike() !== "").assertTrue(); 671 } catch (e) { 672 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 673 expect(null).assertFail(); 674 } 675 query = null; 676 done(); 677 }) 678 679 /** 680 * @tc.name: QueryIsNullInvalidTypeArgsTest 681 * @tc.desc: Test Js Api Query.IsNull() with invalid type args 682 * @tc.type: FUNC 683 * @tc.require: issueNumber 684 */ 685 it('QueryIsNullInvalidTypeArgsTest', 0, async function (done) { 686 var query = null; 687 try { 688 query = new ddm.Query(); 689 expect("").assertEqual(query.getSqlLike()); 690 query.isNull(0); 691 console.info("should throw exception on invalid arguments"); 692 expect(null).assertFail(); 693 } catch (e) { 694 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 695 expect(e.code == 401).assertTrue(); 696 } 697 query = null; 698 done(); 699 }) 700 701 /** 702 * @tc.name: QueryIsNullInvalidLessArgsTest 703 * @tc.desc: Test Js Api Query.IsNull() with invalid less args 704 * @tc.type: FUNC 705 * @tc.require: issueNumber 706 */ 707 it('QueryIsNullInvalidLessArgsTest', 0, async function (done) { 708 var query = null; 709 try { 710 query = new ddm.Query(); 711 expect("").assertEqual(query.getSqlLike()); 712 query.isNull(); 713 console.info("should throw exception on invalid arguments"); 714 expect(null).assertFail(); 715 } catch (e) { 716 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 717 expect(e.code == 401).assertTrue(); 718 } 719 query = null; 720 done(); 721 }) 722 723 /** 724 * @tc.name: QueryInNumberSucTest 725 * @tc.desc: Test Js Api Query.InNumber() successfully 726 * @tc.type: FUNC 727 * @tc.require: issueNumber 728 */ 729 it('QueryInNumberSucTest', 0, async function (done) { 730 var query = null; 731 try { 732 query = new ddm.Query(); 733 expect("").assertEqual(query.getSqlLike()); 734 var i8 = new Int8Array([-21, 31]); 735 query.reset().inNumber("key", i8); 736 console.info("inNumber(Int8Array([-21,31]) => " + query.getSqlLike()); 737 var u8 = new Uint8Array([-21, 31]); 738 query.reset().inNumber("key", u8); 739 console.info("inNumber(Uint8Array([-21,31]) => " + query.getSqlLike()); 740 var c8 = new Uint8ClampedArray([-21, 31]); 741 query.reset().inNumber("key", c8); 742 console.info("inNumber(Uint8Array([-21,31]) => " + query.getSqlLike()); 743 var i16 = new Int16Array([-21, 31]); 744 query.reset().inNumber("key", i16); 745 console.info("inNumber(Int16Array([-21,31]) => " + query.getSqlLike()); 746 var u16 = new Uint16Array([-21, 31]); 747 query.reset().inNumber("key", u16); 748 console.info("inNumber(Uint16Array([-21,31]) => " + query.getSqlLike()); 749 var i32 = new Int32Array([-21, 31]); 750 query.reset().inNumber("key", i32); 751 console.info("inNumber(Int32Array([-21,31]) => " + query.getSqlLike()); 752 var u32 = new Uint32Array([-21, 31]); 753 query.reset().inNumber("key", u32); 754 console.info("inNumber(UInt32Array([-21,31]) => " + query.getSqlLike()); 755 var f32 = new Float32Array([-21, 31]); 756 query.reset().inNumber("key", f32); 757 console.info("inNumber(Float32Array([-21,31]) => " + query.getSqlLike()); 758 var f32e = new Float32Array([21, 31, "a"]); 759 query.reset().inNumber("key", f32e); 760 console.info("inNumber(Float32Array([-21,31, 'a']) => " + query.getSqlLike()); 761 var f64 = new Float64Array([-21, 31]); 762 query.reset().inNumber("key", f64); 763 console.info("inNumber(Float64Array([-21,31]) => " + query.getSqlLike()); 764 query.reset(); 765 var u64 = new BigUint64Array([21n, 31n]); 766 query.reset().inNumber("key", u64); 767 var b64 = new BigInt64Array([21n, 31n]); 768 query.reset().inNumber("key", b64); 769 expect(true).assertTrue(); 770 } catch (e) { 771 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 772 expect(null).assertFail(); 773 } 774 query = null; 775 done(); 776 }) 777 778 /** 779 * @tc.name: QueryInNumberInvalidMoreArgsTest 780 * @tc.desc: Test Js Api Query.InNumber() with invalid more args 781 * @tc.type: FUNC 782 * @tc.require: issueNumber 783 */ 784 it('QueryInNumberInvalidMoreArgsTest', 0, async function (done) { 785 var query = null; 786 try { 787 query = new ddm.Query(); 788 expect("").assertEqual(query.getSqlLike()); 789 query.inNumber("key", 0); 790 console.info("should throw exception on invalid arguments"); 791 expect(null).assertFail(); 792 } catch (e) { 793 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 794 expect(e.code == 401).assertTrue(); 795 } 796 query = null; 797 done(); 798 }) 799 800 /** 801 * @tc.name: QueryInNumberInvalidLessArgsTest 802 * @tc.desc: Test Js Api Query.InNumber() with invalid less args 803 * @tc.type: FUNC 804 * @tc.require: issueNumber 805 */ 806 it('QueryInNumberInvalidTypeArgsTest', 0, async function (done) { 807 var query = null; 808 try { 809 query = new ddm.Query(); 810 expect("").assertEqual(query.getSqlLike()); 811 query.inNumber([0, 1]); 812 console.info("should throw exception on invalid arguments"); 813 expect(null).assertFail(); 814 } catch (e) { 815 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 816 expect(e.code == 401).assertTrue(); 817 } 818 query = null; 819 done(); 820 }) 821 822 /** 823 * @tc.name: QueryInNumberBoundaryCallsTest 824 * @tc.desc: Test Js Api Query.InNumber() boundary calls 825 * @tc.type: FUNC 826 * @tc.require: issueNumber 827 */ 828 it('QueryInNumberBoundaryCallsTest', 0, async function (done) { 829 var query = null; 830 try { 831 query = new ddm.Query(); 832 console.info("typeof([1, 2, 97])" + typeof ([1, 2, 97])) 833 console.info("typeof([1, 2, 97][0])" + typeof ([1, 2, 97][0])) 834 query.inNumber("key", [1, 2, 97]); 835 console.info("inNumber([1, 2, 97]) => " + query.getSqlLike()); 836 query.reset(); 837 query.inNumber("key1", [-1, 3, 987654.123, 0xabc123456]); 838 console.info("inNumber([1, 2, 0xa1234567890123456]) => " + query.getSqlLike()); 839 query.reset(); 840 query.inNumber("key2", [-1, 3, -987654.123, 0xabc123456]); 841 console.info("inNumber([1, 2, 0xa1234567890123456]) => " + query.getSqlLike()); 842 query.reset(); 843 query.inNumber("key3", [-1, 4, -987654.123, Number.MAX_VALUE]); 844 console.info("inNumber([1, 2, Number.MAX_VALUE]) => " + query.getSqlLike()); 845 query.reset(); 846 query.inNumber("key4", [1, -2.3, Number.MIN_VALUE, Number.MAX_VALUE]); 847 console.info("inNumber([1, -2.3, Number.MAX_VALUE]) => " + query.getSqlLike()); 848 expect(query.getSqlLike() !== "").assertTrue(); 849 console.info("query is " + query.getSqlLike()); 850 query.reset(); 851 } catch (e) { 852 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 853 expect(null).assertFail(); 854 } 855 query = null; 856 done(); 857 }) 858 859 /** 860 * @tc.name: QueryInStringSucTest 861 * @tc.desc: Test Js Api Query.InString() successfully 862 * @tc.type: FUNC 863 * @tc.require: issueNumber 864 */ 865 it('QueryInStringSucTest', 0, async function (done) { 866 var query = null; 867 try { 868 query = new ddm.Query(); 869 expect("").assertEqual(query.getSqlLike()); 870 query.inString("key", ["a2z", 'z2a']); 871 query.inString("key2", ["AAA"]); 872 console.info("query is " + query.getSqlLike()); 873 expect(query.getSqlLike() !== "").assertTrue(); 874 } catch (e) { 875 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 876 expect(null).assertFail(); 877 } 878 query = null; 879 done(); 880 }) 881 882 /** 883 * @tc.name: QueryInStringInvalidMoreArgsTest 884 * @tc.desc: Test Js Api Query.InString() with invalid more args 885 * @tc.type: FUNC 886 * @tc.require: issueNumber 887 */ 888 it('QueryInStringInvalidMoreArgsTest', 0, async function (done) { 889 var query = null; 890 try { 891 query = new ddm.Query(); 892 expect("").assertEqual(query.getSqlLike()); 893 query.inString("key", ["a2z", 'z2a'], ["AAA"]); 894 console.info("should throw exception on invalid arguments"); 895 expect(true).assertTrue(); 896 } catch (e) { 897 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 898 expect(null).assertFail(); 899 } 900 query = null; 901 done(); 902 }) 903 904 /** 905 * @tc.name: QueryInStringInvalidTypeArgsTest 906 * @tc.desc: Test Js Api Query.InString() with invalid type args 907 * @tc.type: FUNC 908 * @tc.require: issueNumber 909 */ 910 it('QueryInStringInvalidTypeArgsTest', 0, async function (done) { 911 var query = null; 912 try { 913 query = new ddm.Query(); 914 expect("").assertEqual(query.getSqlLike()); 915 query.inString("key", 0); 916 console.info("should throw exception on invalid arguments"); 917 expect(null).assertFail(); 918 } catch (e) { 919 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 920 expect(e.code == 401).assertTrue(); 921 } 922 query = null; 923 done(); 924 }) 925 926 /** 927 * @tc.name: QueryInStringInvalidListArgsTest 928 * @tc.desc: Test Js Api Query.InString() with invalid list args 929 * @tc.type: FUNC 930 * @tc.require: issueNumber 931 */ 932 it('QueryInStringInvalidListArgsTest', 0, async function (done) { 933 var query = null; 934 try { 935 query = new ddm.Query(); 936 expect("").assertEqual(query.getSqlLike()); 937 query.inString("key", [0, 1]); 938 console.info("should throw exception on invalid arguments"); 939 expect(null).assertFail(); 940 } catch (e) { 941 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 942 expect(e.code == 401).assertTrue(); 943 } 944 query = null; 945 done(); 946 }) 947 948 /** 949 * @tc.name: QueryNotInNumberSucTest 950 * @tc.desc: Test Js Api Query.NotInNumber() successfully 951 * @tc.type: FUNC 952 * @tc.require: issueNumber 953 */ 954 it('QueryNotInNumberSucTest', 0, async function (done) { 955 var query = null; 956 try { 957 query = new ddm.Query(); 958 expect("").assertEqual(query.getSqlLike()); 959 query.notInNumber("key", [1, 2]); 960 query.notInNumber("key", [1000]); 961 expect(query.getSqlLike() !== "").assertTrue(); 962 console.info("query is " + query.getSqlLike()); 963 } catch (e) { 964 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 965 expect(null).assertFail(); 966 } 967 query = null; 968 done(); 969 }) 970 971 /** 972 * @tc.name: QueryNotInNumberInvalidMoreArgsTest 973 * @tc.desc: Test Js Api Query.NotInNumber() with invalid more arguments 974 * @tc.type: FUNC 975 * @tc.require: issueNumber 976 */ 977 it('QueryNotInNumberInvalidMoreArgsTest', 0, async function (done) { 978 var query = null; 979 try { 980 query = new ddm.Query(); 981 expect("").assertEqual(query.getSqlLike()); 982 query.notInNumber("key", [1], 2); 983 console.info("should not throw exception on invalid arguments"); 984 expect(query.getSqlLike() !== "").assertTrue(); 985 } catch (e) { 986 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 987 expect(null).assertFail(); 988 } 989 query = null; 990 done(); 991 }) 992 993 /** 994 * @tc.name: QueryNotInNumberInvalidTypeArgsTest 995 * @tc.desc: Test Js Api Query.NotInNumber() with invalid type arguments 996 * @tc.type: FUNC 997 * @tc.require: issueNumber 998 */ 999 it('QueryNotInNumberInvalidTypeArgsTest', 0, async function (done) { 1000 var query = null; 1001 try { 1002 query = new ddm.Query(); 1003 expect("").assertEqual(query.getSqlLike()); 1004 query.notInNumber("key", ["string"]); 1005 expect(query.getSqlLike() !== "").assertTrue(); 1006 console.info("should throw exception on invalid arguments"); 1007 expect(null).assertFail(); 1008 } catch (e) { 1009 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1010 expect(e.code == 401).assertTrue(); 1011 } 1012 query = null; 1013 done(); 1014 }) 1015 1016 /** 1017 * @tc.name: QueryNotInStringSucTest 1018 * @tc.desc: Test Js Api Query.NotInString() successfully 1019 * @tc.type: FUNC 1020 * @tc.require: issueNumber 1021 */ 1022 it('QueryNotInStringSucTest', 0, async function (done) { 1023 var query = null; 1024 try { 1025 query = new ddm.Query(); 1026 expect("").assertEqual(query.getSqlLike()); 1027 query.notInString("key", ["v1", "v2"]); 1028 query.notInString("key", ["v1", "NaN"]); 1029 expect(query.getSqlLike() !== "").assertTrue(); 1030 console.info("query is " + query.getSqlLike()); 1031 } catch (e) { 1032 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1033 expect(null).assertFail(); 1034 } 1035 query = null; 1036 done(); 1037 }) 1038 1039 /** 1040 * @tc.name: QueryNotInStringInvalidMoreArgsTest 1041 * @tc.desc: Test Js Api Query.NotInString() with invalid more args 1042 * @tc.type: FUNC 1043 * @tc.require: issueNumber 1044 */ 1045 it('QueryNotInStringInvalidMoreArgsTest', 0, async function (done) { 1046 var query = null; 1047 try { 1048 query = new ddm.Query(); 1049 expect("").assertEqual(query.getSqlLike()); 1050 query.notInString("key", ["", "abccd"], 2); 1051 console.info("should not throw exception on invalid arguments"); 1052 expect(query.getSqlLike() !== "").assertTrue(); 1053 } catch (e) { 1054 console.error("throw exception : " + `, 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: QueryNotInStringInvalidTypeArgsTest 1063 * @tc.desc: Test Js Api Query.NotInString() with invalid type args 1064 * @tc.type: FUNC 1065 * @tc.require: issueNumber 1066 */ 1067 it('QueryNotInStringInvalidTypeArgsTest', 0, async function (done) { 1068 var query = null; 1069 try { 1070 query = new ddm.Query(); 1071 expect("").assertEqual(query.getSqlLike()); 1072 query.notInString("key", [1, 2]); 1073 console.info("should throw exception on invalid arguments"); 1074 expect(null).assertFail(); 1075 } catch (e) { 1076 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1077 expect(e.code == 401).assertTrue(); 1078 } 1079 query = null; 1080 done(); 1081 }) 1082 1083 /** 1084 * @tc.name: QueryLikeSucTest 1085 * @tc.desc: Test Js Api Query.Like() successfully 1086 * @tc.type: FUNC 1087 * @tc.require: issueNumber 1088 */ 1089 it('QueryLikeSucTest', 0, async function (done) { 1090 var query = null; 1091 try { 1092 query = new ddm.Query(); 1093 expect("").assertEqual(query.getSqlLike()); 1094 query.like("key", "v1"); 1095 query.like("key2", "v2"); 1096 expect(query.getSqlLike() !== "").assertTrue(); 1097 console.info("query is " + query.getSqlLike()); 1098 } catch (e) { 1099 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1100 expect(null).assertFail(); 1101 } 1102 query = null; 1103 done(); 1104 }) 1105 1106 /** 1107 * @tc.name: QueryLikeInvalidArgsTypeTest 1108 * @tc.desc: Test Js Api Query.Like() with invalid type args 1109 * @tc.type: FUNC 1110 * @tc.require: issueNumber 1111 */ 1112 it('QueryLikeInvalidArgsTypeTest', 0, async function (done) { 1113 var query = null; 1114 try { 1115 query = new ddm.Query(); 1116 expect("").assertEqual(query.getSqlLike()); 1117 query.like("key", 0); 1118 console.info("should throw exception on invalid arguments"); 1119 expect(null).assertFail(); 1120 } catch (e) { 1121 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1122 expect(e.code == 401).assertTrue(); 1123 } 1124 query = null; 1125 done(); 1126 }) 1127 1128 /** 1129 * @tc.name: QueryLikeInvalidMoreTypesTest 1130 * @tc.desc: Test Js Api Query.Like() with invalid more args 1131 * @tc.type: FUNC 1132 * @tc.require: issueNumber 1133 */ 1134 it('QueryLikeInvalidMoreTypesTest', 0, async function (done) { 1135 var query = null; 1136 try { 1137 query = new ddm.Query(); 1138 expect("").assertEqual(query.getSqlLike()); 1139 query.like("key", "str1", "str2"); 1140 console.info("should not throw exception on invalid arguments"); 1141 expect(query.getSqlLike() !== "").assertTrue(); 1142 } catch (e) { 1143 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 1144 expect(null).assertFail(); 1145 } 1146 query = null; 1147 done(); 1148 }) 1149 1150 /** 1151 * @tc.name: QueryUnlikeSucTest 1152 * @tc.desc: Test Js Api Query.Unlike() successfully 1153 * @tc.type: FUNC 1154 * @tc.require: issueNumber 1155 */ 1156 it('QueryUnlikeSucTest', 0, async function (done) { 1157 var query = null; 1158 try { 1159 query = new ddm.Query(); 1160 expect("").assertEqual(query.getSqlLike()); 1161 query.unlike("key", "v1"); 1162 expect(query.getSqlLike() !== "").assertTrue(); 1163 console.info("query is " + query.getSqlLike()); 1164 } catch (e) { 1165 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1166 expect(null).assertFail(); 1167 } 1168 query = null; 1169 done(); 1170 }) 1171 1172 /** 1173 * @tc.name: QueryUnlikeInvalidTypeArgsTest 1174 * @tc.desc: Test Js Api Query.Unlike() with invalid type args 1175 * @tc.type: FUNC 1176 * @tc.require: issueNumber 1177 */ 1178 it('QueryUnlikeInvalidTypeArgsTest', 0, async function (done) { 1179 var query = null; 1180 try { 1181 query = new ddm.Query(); 1182 expect("").assertEqual(query.getSqlLike()); 1183 query.unlike("key", 0); 1184 console.info("should throw exception on invalid arguments"); 1185 expect(null).assertFail(); 1186 } catch (e) { 1187 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1188 expect(e.code == 401).assertTrue(); 1189 } 1190 query = null; 1191 done(); 1192 }) 1193 1194 /** 1195 * @tc.name: QueryUnlikeInvalidMoreArgsTest 1196 * @tc.desc: Test Js Api Query.Unlike() with invalid more args 1197 * @tc.type: FUNC 1198 * @tc.require: issueNumber 1199 */ 1200 it('QueryUnlikeInvalidMoreArgsTest', 0, async function (done) { 1201 var query = null; 1202 try { 1203 query = new ddm.Query(); 1204 expect("").assertEqual(query.getSqlLike()); 1205 query.unlike("key", "str1", "str2"); 1206 console.info("should not throw exception on invalid arguments"); 1207 expect(query.getSqlLike() !== "").assertTrue(); 1208 } catch (e) { 1209 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 1210 expect(null).assertFail(); 1211 } 1212 query = null; 1213 done(); 1214 }) 1215 1216 /** 1217 * @tc.name: QueryAndSucTest 1218 * @tc.desc: Test Js Api Query.And() successfully 1219 * @tc.type: FUNC 1220 * @tc.require: issueNumber 1221 */ 1222 it('QueryAndSucTest', 0, async function (done) { 1223 var query = null; 1224 try { 1225 query = new ddm.Query(); 1226 expect("").assertEqual(query.getSqlLike()); 1227 query.notEqualTo("key", 0); 1228 query.and(); 1229 query.notEqualTo("key", "v1"); 1230 expect(query.getSqlLike() !== "").assertTrue(); 1231 console.info("query is " + query.getSqlLike()); 1232 } catch (e) { 1233 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1234 expect(null).assertFail(); 1235 } 1236 query = null; 1237 done(); 1238 }) 1239 1240 /** 1241 * @tc.name: QueryAndInvalidArgsTest 1242 * @tc.desc: Test Js Api Query.And() invalid args 1243 * @tc.type: FUNC 1244 * @tc.require: issueNumber 1245 */ 1246 it('QueryAndInvalidArgsTest', 0, async function (done) { 1247 var query = null; 1248 try { 1249 query = new ddm.Query(); 1250 expect("").assertEqual(query.getSqlLike()); 1251 query.notEqualTo("key", 0).and(1).notInNumber("key", [1, 3]); 1252 console.info("should throw exception on invalid arguments"); 1253 expect(null).assertFail(); 1254 } catch (e) { 1255 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1256 expect(true).assertTrue(); 1257 } 1258 query = null; 1259 done(); 1260 }) 1261 1262 /** 1263 * @tc.name: QueryOrSucTest 1264 * @tc.desc: Test Js Api Query.Or() successfully 1265 * @tc.type: FUNC 1266 * @tc.require: issueNumber 1267 */ 1268 it('QueryOrSucTest', 0, async function (done) { 1269 var query = null; 1270 try { 1271 query = new ddm.Query(); 1272 expect("").assertEqual(query.getSqlLike()); 1273 query.notEqualTo("key", 0); 1274 query.or(); 1275 query.notEqualTo("key", "v1"); 1276 expect(query.getSqlLike() !== "").assertTrue(); 1277 console.info("query is " + query.getSqlLike()); 1278 } catch (e) { 1279 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1280 expect(null).assertFail(); 1281 } 1282 query = null; 1283 done(); 1284 }) 1285 1286 /** 1287 * @tc.name: QueryOrInvalidArgsTest 1288 * @tc.desc: Test Js Api Query.Or() with invalid args 1289 * @tc.type: FUNC 1290 * @tc.require: issueNumber 1291 */ 1292 it('QueryOrInvalidArgsTest', 0, async function (done) { 1293 var query = null; 1294 try { 1295 query = new ddm.Query(); 1296 expect("").assertEqual(query.getSqlLike()); 1297 query.notEqualTo("key", 0).or(1).notInNumber("key", [1, 3]); 1298 console.info("should throw exception on invalid arguments"); 1299 expect(null).assertFail(); 1300 } catch (e) { 1301 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1302 expect(true).assertTrue(); 1303 } 1304 query = null; 1305 done(); 1306 }) 1307 1308 /** 1309 * @tc.name: QueryOrderByAscSucTest 1310 * @tc.desc: Test Js Api Query.OrderByAsc() successfully 1311 * @tc.type: FUNC 1312 * @tc.require: issueNumber 1313 */ 1314 it('QueryOrderByAscSucTest', 0, async function (done) { 1315 var query = null; 1316 try { 1317 query = new ddm.Query(); 1318 expect("").assertEqual(query.getSqlLike()); 1319 query.notEqualTo("key", 0); 1320 query.orderByAsc("sortbykey"); 1321 expect(query.getSqlLike() !== "").assertTrue(); 1322 console.info("query is " + query.getSqlLike()); 1323 } catch (e) { 1324 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1325 expect(null).assertFail(); 1326 } 1327 query = null; 1328 done(); 1329 }) 1330 1331 /** 1332 * @tc.name: QueryOrderByAscInvalidTypeArgsTest 1333 * @tc.desc: Test Js Api Query.OrderByAsc() with invalid type args 1334 * @tc.type: FUNC 1335 * @tc.require: issueNumber 1336 */ 1337 it('QueryOrderByAscInvalidTypeArgsTest', 0, async function (done) { 1338 var query = null; 1339 try { 1340 query = new ddm.Query(); 1341 expect("").assertEqual(query.getSqlLike()); 1342 query.notEqualTo("key", false).orderByAsc(1); 1343 console.info("should throw exception on invalid arguments"); 1344 expect(null).assertFail(); 1345 } catch (e) { 1346 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1347 expect(e.code == 401).assertTrue(); 1348 } 1349 query = null; 1350 done(); 1351 }) 1352 1353 /** 1354 * @tc.name: QueryOrderByAscWithNullTest 1355 * @tc.desc: Test Js Api Query.OrderByAsc() null args 1356 * @tc.type: FUNC 1357 * @tc.require: issueNumber 1358 */ 1359 it('QueryOrderByAscWithNullTest', 0, async function (done) { 1360 var query = null; 1361 try { 1362 query = new ddm.Query(); 1363 expect("").assertEqual(query.getSqlLike()); 1364 query.orderByAsc(); 1365 console.info("should throw exception on invalid arguments"); 1366 expect(null).assertFail(); 1367 } catch (e) { 1368 console.error("throw exception is ok : "); 1369 expect(e.code == 401).assertTrue(); 1370 } 1371 query = null; 1372 done(); 1373 }) 1374 1375 /** 1376 * @tc.name: QueryOrderByDescTest 1377 * @tc.desc: Test Js Api Query.OrderByDesc() successfully 1378 * @tc.type: FUNC 1379 * @tc.require: issueNumber 1380 */ 1381 it('QueryOrderByDescTest', 0, async function (done) { 1382 var query = null; 1383 try { 1384 query = new ddm.Query(); 1385 expect("").assertEqual(query.getSqlLike()); 1386 query.notEqualTo("key", 0); 1387 query.orderByDesc("sortbykey"); 1388 expect(query.getSqlLike() !== "").assertTrue(); 1389 console.info("query is " + query.getSqlLike()); 1390 } catch (e) { 1391 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1392 expect(null).assertFail(); 1393 } 1394 query = null; 1395 done(); 1396 }) 1397 1398 /** 1399 * @tc.name: QueryOrderByDescInvalidTypeArgsTest 1400 * @tc.desc: Test Js Api Query.OrderByDesc() with invalid type args 1401 * @tc.type: FUNC 1402 * @tc.require: issueNumber 1403 */ 1404 it('QueryOrderByDescInvalidTypeArgsTest', 0, async function (done) { 1405 var query = null; 1406 try { 1407 query = new ddm.Query(); 1408 expect("").assertEqual(query.getSqlLike()); 1409 query.notEqualTo("key", false).orderByDesc(1); 1410 console.info("should throw exception on invalid arguments"); 1411 expect(null).assertFail(); 1412 } catch (e) { 1413 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1414 expect(e.code == 401).assertTrue(); 1415 } 1416 query = null; 1417 done(); 1418 }) 1419 1420 /** 1421 * @tc.name: QueryOrderByDescNullTest 1422 * @tc.desc: Test Js Api Query.OrderByDesc() with null args 1423 * @tc.type: FUNC 1424 * @tc.require: issueNumber 1425 */ 1426 it('QueryOrderByDescNullTest', 0, async function (done) { 1427 var query = null; 1428 try { 1429 query = new ddm.Query(); 1430 expect("").assertEqual(query.getSqlLike()); 1431 query.orderByDesc(); 1432 console.info("should throw exception on invalid arguments"); 1433 expect(null).assertFail(); 1434 } catch (e) { 1435 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1436 expect(e.code == 401).assertTrue(); 1437 } 1438 query = null; 1439 done(); 1440 }) 1441 1442 /** 1443 * @tc.name: QueryLimitSucTest 1444 * @tc.desc: Test Js Api Query.Limit() successfully 1445 * @tc.type: FUNC 1446 * @tc.require: issueNumber 1447 */ 1448 it('QueryLimitSucTest', 0, async function (done) { 1449 var query = null; 1450 try { 1451 query = new ddm.Query(); 1452 expect("").assertEqual(query.getSqlLike()); 1453 query.notEqualTo("key", "vx"); 1454 expect(query.getSqlLike() !== "").assertTrue(); 1455 query.limit(10, 2); 1456 expect(query.getSqlLike() !== "").assertTrue(); 1457 console.info("query is " + query.getSqlLike()); 1458 } catch (e) { 1459 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1460 expect(null).assertFail(); 1461 } 1462 query = null; 1463 done(); 1464 }) 1465 1466 /** 1467 * @tc.name: QueryLimitMoreArgsTest 1468 * @tc.desc: Test Js Api Query.Limit() with invalid more args 1469 * @tc.type: FUNC 1470 * @tc.require: issueNumber 1471 */ 1472 it('QueryLimitMoreArgsTest', 0, async function (done) { 1473 var query = null; 1474 try { 1475 query = new ddm.Query(); 1476 expect("").assertEqual(query.getSqlLike()); 1477 query.notEqualTo("key", false).limit(10, 2, "any"); 1478 console.info("should not throw exception on invalid arguments"); 1479 expect(query.getSqlLike() !== "").assertTrue(); 1480 } catch (e) { 1481 console.error("throw exception: " + `, error code is ${e.code}, message is ${e.message}`); 1482 expect(null).assertFail(); 1483 } 1484 query = null; 1485 done(); 1486 }) 1487 1488 /** 1489 * @tc.name: QueryLimitLessArgsTest 1490 * @tc.desc: Test Js Api Query.Limit() with invalid less args 1491 * @tc.type: FUNC 1492 * @tc.require: issueNumber 1493 */ 1494 it('QueryLimitLessArgsTest', 0, async function (done) { 1495 var query = null; 1496 try { 1497 query = new ddm.Query(); 1498 expect("").assertEqual(query.getSqlLike()); 1499 query.notEqualTo("key", false).limit(10); 1500 console.info("should throw exception on invalid arguments"); 1501 expect(null).assertFail(); 1502 } catch (e) { 1503 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1504 expect(e.code == 401).assertTrue(); 1505 } 1506 query = null; 1507 done(); 1508 }) 1509 1510 /** 1511 * @tc.name: QueryLimitInvalidTypeArgsTest 1512 * @tc.desc: Test Js Api Query.Limit() with invalid type args 1513 * @tc.type: FUNC 1514 * @tc.require: issueNumber 1515 */ 1516 it('QueryLimitInvalidTypeArgsTest', 0, async function (done) { 1517 var query = null; 1518 try { 1519 query = new ddm.Query(); 1520 expect("").assertEqual(query.getSqlLike()); 1521 query.notEqualTo("key", false).limit("any", 10); 1522 console.info("should throw exception on invalid arguments"); 1523 console.info("query is " + query.getSqlLike()); 1524 expect(null).assertFail(); 1525 } catch (e) { 1526 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1527 expect(e.code == 401).assertTrue(); 1528 } 1529 query = null; 1530 done(); 1531 }) 1532 1533 /** 1534 * @tc.name: QueryIsNotNullSucTest 1535 * @tc.desc: Test Js Api Query.IsNotNull() successfully 1536 * @tc.type: FUNC 1537 * @tc.require: issueNumber 1538 */ 1539 it('QueryIsNotNullSucTest', 0, async function (done) { 1540 var query = null; 1541 try { 1542 query = new ddm.Query(); 1543 expect("").assertEqual(query.getSqlLike()); 1544 query.isNotNull("key"); 1545 expect(query.getSqlLike() !== "").assertTrue(); 1546 console.info("query is " + query.getSqlLike()); 1547 } catch (e) { 1548 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1549 expect(null).assertFail(); 1550 } 1551 query = null; 1552 done(); 1553 }) 1554 1555 /** 1556 * @tc.name: QueryIsNotNullMoreArgsTest 1557 * @tc.desc: Test Js Api Query.IsNotNull() with invalid more args 1558 * @tc.type: FUNC 1559 * @tc.require: issueNumber 1560 */ 1561 it('QueryIsNotNullMoreArgsTest', 0, async function (done) { 1562 var query = null; 1563 try { 1564 query = new ddm.Query(); 1565 expect("").assertEqual(query.getSqlLike()); 1566 query.isNotNull("key2", "any"); 1567 console.info("should throw exception on invalid arguments"); 1568 expect(query.getSqlLike() !== "").assertTrue(); 1569 } catch (e) { 1570 console.error("throw exception: " + `, error code is ${e.code}, message is ${e.message}`); 1571 expect(null).assertFail(); 1572 } 1573 query = null; 1574 done(); 1575 }) 1576 1577 /** 1578 * @tc.name: QueryIsNotNullInvalidTypeArgsTest 1579 * @tc.desc: Test Js Api Query.IsNotNull() with invalid type args 1580 * @tc.type: FUNC 1581 * @tc.require: issueNumber 1582 */ 1583 it('QueryIsNotNullInvalidTypeArgsTest', 0, async function (done) { 1584 var query = null; 1585 try { 1586 query = new ddm.Query(); 1587 expect("").assertEqual(query.getSqlLike()); 1588 query.isNotNull(1); 1589 console.info("should throw exception on invalid arguments"); 1590 expect(null).assertFail(); 1591 } catch (e) { 1592 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1593 expect(e.code == 401).assertTrue(); 1594 } 1595 query = null; 1596 done(); 1597 }) 1598 1599 /** 1600 * @tc.name: QueryBeginGroupSucTest 1601 * @tc.desc: Test Js Api Query.BeginGroup() successfully 1602 * @tc.type: FUNC 1603 * @tc.require: issueNumber 1604 */ 1605 it('QueryBeginGroupSucTest', 0, async function (done) { 1606 var query = null; 1607 try { 1608 query = new ddm.Query(); 1609 expect("").assertEqual(query.getSqlLike()); 1610 query.beginGroup(); 1611 query.isNotNull("$.name"); 1612 query.endGroup(); 1613 expect(query.getSqlLike() !== "").assertTrue(); 1614 console.info("query is " + query.getSqlLike()); 1615 } catch (e) { 1616 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1617 expect(null).assertFail(); 1618 } 1619 query = null; 1620 done(); 1621 }) 1622 1623 /** 1624 * @tc.name: QueryBeginGroupInvalidTypeArgsTest 1625 * @tc.desc: Test Js Api Query.BeginGroup() with invalid type args 1626 * @tc.type: FUNC 1627 * @tc.require: issueNumber 1628 */ 1629 it('QueryBeginGroupInvalidTypeArgsTest', 0, async function (done) { 1630 var query = null; 1631 try { 1632 query = new ddm.Query(); 1633 expect("").assertEqual(query.getSqlLike()); 1634 query.beginGroup(1); 1635 console.info("should throw exception on invalid arguments"); 1636 expect(null).assertFail(); 1637 } catch (e) { 1638 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1639 expect(true).assertTrue(); 1640 } 1641 query = null; 1642 done(); 1643 }) 1644 1645 /** 1646 * @tc.name: QueryBeginGroupInvalidMoreArgsTest 1647 * @tc.desc: Test Js Api Query.BeginGroup() with invalid more args 1648 * @tc.type: FUNC 1649 * @tc.require: issueNumber 1650 */ 1651 it('QueryBeginGroupInvalidMoreArgsTest', 0, async function (done) { 1652 var query = null; 1653 try { 1654 query = new ddm.Query(); 1655 expect("").assertEqual(query.getSqlLike()); 1656 query.beginGroup("any", 1); 1657 console.info("should throw exception on invalid arguments"); 1658 expect(null).assertFail(); 1659 } catch (e) { 1660 console.error("throw exception: " + `, error code is ${e.code}, message is ${e.message}`); 1661 expect(true).assertTrue(); 1662 } 1663 query = null; 1664 done(); 1665 }) 1666 1667 1668 /** 1669 * @tc.name: QueryEndGroupSucTest 1670 * @tc.desc: Test Js Api Query.EndGroup() successfully 1671 * @tc.type: FUNC 1672 * @tc.require: issueNumber 1673 */ 1674 it('QueryEndGroupSucTest', 0, async function (done) { 1675 var query = null; 1676 try { 1677 query = new ddm.Query(); 1678 expect("").assertEqual(query.getSqlLike()); 1679 query.beginGroup(); 1680 query.isNotNull("name"); 1681 query.endGroup(); 1682 expect(query.getSqlLike() !== "").assertTrue(); 1683 } catch (e) { 1684 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1685 expect(null).assertFail(); 1686 } 1687 query = null; 1688 done(); 1689 }) 1690 1691 /** 1692 * @tc.name: QueryEndGroupInvalidTypeArgsTest 1693 * @tc.desc: Test Js Api Query.EndGroup() with invalid type args 1694 * @tc.type: FUNC 1695 * @tc.require: issueNumber 1696 */ 1697 it('QueryEndGroupInvalidTypeArgsTest', 0, async function (done) { 1698 var query = null; 1699 try { 1700 query = new ddm.Query(); 1701 expect("").assertEqual(query.getSqlLike()); 1702 query.endGroup(0); 1703 console.info("should throw exception on invalid arguments"); 1704 expect(null).assertFail(); 1705 } catch (e) { 1706 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1707 expect(true).assertTrue(); 1708 } 1709 query = null; 1710 done(); 1711 }) 1712 1713 /** 1714 * @tc.name: QueryPrefixKeySucTest 1715 * @tc.desc: Test Js Api Query.PrefixKey() successfully 1716 * @tc.type: FUNC 1717 * @tc.require: issueNumber 1718 */ 1719 it('QueryPrefixKeySucTest', 0, async function (done) { 1720 var query = null; 1721 try { 1722 query = new ddm.Query(); 1723 expect("").assertEqual(query.getSqlLike()); 1724 query.prefixKey("$.name"); 1725 query.prefixKey("0"); 1726 expect(query.getSqlLike() !== "").assertTrue(); 1727 console.info("query is " + query.getSqlLike()); 1728 } catch (e) { 1729 expect(null).assertFail(); 1730 } 1731 query = null; 1732 done(); 1733 }) 1734 1735 /** 1736 * @tc.name: QueryPrefixKeyInvalidMoreArgsTest 1737 * @tc.desc: Test Js Api Query.PrefixKey() with invalid more args 1738 * @tc.type: FUNC 1739 * @tc.require: issueNumber 1740 */ 1741 it('QueryPrefixKeyInvalidMoreArgsTest', 0, async function (done) { 1742 var query = null; 1743 try { 1744 query = new ddm.Query(); 1745 expect("").assertEqual(query.getSqlLike()); 1746 query.prefixKey("k", "any"); 1747 console.info("should not throw exception on invalid arguments"); 1748 expect(query.getSqlLike() !== "").assertTrue(); 1749 } catch (e) { 1750 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 1751 expect(null).assertFail(); 1752 } 1753 query = null; 1754 done(); 1755 }) 1756 1757 /** 1758 * @tc.name: QueryPrefixKeyInvalidTypeArgsTest 1759 * @tc.desc: Test Js Api Query.PrefixKey() with invalid type args 1760 * @tc.type: FUNC 1761 * @tc.require: issueNumber 1762 */ 1763 it('QueryPrefixKeyInvalidTypeArgsTest', 0, async function (done) { 1764 var query = null; 1765 try { 1766 query = new ddm.Query(); 1767 expect("").assertEqual(query.getSqlLike()); 1768 query.prefixKey(123); 1769 console.info("should throw exception on invalid arguments"); 1770 expect(null).assertFail(); 1771 } catch (e) { 1772 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1773 expect(e.code == 401).assertTrue(); 1774 } 1775 query = null; 1776 done(); 1777 }) 1778 1779 /** 1780 * @tc.name: QuerySetSuggestIndexSucTest 1781 * @tc.desc: Test Js Api Query.SetSuggestIndex() successfully 1782 * @tc.type: FUNC 1783 * @tc.require: issueNumber 1784 */ 1785 it('QuerySetSuggestIndexSucTest', 0, async function (done) { 1786 var query = null; 1787 try { 1788 query = new ddm.Query(); 1789 expect("").assertEqual(query.getSqlLike()); 1790 query.setSuggestIndex("$.name"); 1791 query.setSuggestIndex("0"); 1792 expect(query.getSqlLike() !== "").assertTrue(); 1793 console.info("query is " + query.getSqlLike()); 1794 } catch (e) { 1795 expect(null).assertFail(); 1796 } 1797 query = null; 1798 done(); 1799 }) 1800 1801 /** 1802 * @tc.name: QuerySetSuggestIndexInvalidMoreArgsTest 1803 * @tc.desc: Test Js Api Query.SetSuggestIndex() with invalid more args 1804 * @tc.type: FUNC 1805 * @tc.require: issueNumber 1806 */ 1807 it('QuerySetSuggestIndexInvalidMoreArgsTest', 0, async function (done) { 1808 var query = null; 1809 try { 1810 query = new ddm.Query(); 1811 expect("").assertEqual(query.getSqlLike()); 1812 query.setSuggestIndex("k", "any"); 1813 console.info("should not throw exception on invalid arguments"); 1814 expect(query.getSqlLike() !== "").assertTrue(); 1815 } catch (e) { 1816 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 1817 expect(null).assertFail(); 1818 } 1819 query = null; 1820 done(); 1821 }) 1822 1823 /** 1824 * @tc.name: QuerySetSuggestIndexInvalidTypeArgsTest 1825 * @tc.desc: Test Js Api Query.SetSuggestIndex() with invalid more types 1826 * @tc.type: FUNC 1827 * @tc.require: issueNumber 1828 */ 1829 it('QuerySetSuggestIndexInvalidTypeArgsTest', 0, async function (done) { 1830 var query = null; 1831 try { 1832 query = new ddm.Query(); 1833 expect("").assertEqual(query.getSqlLike()); 1834 query.setSuggestIndex(123); 1835 console.info("should throw exception on invalid arguments"); 1836 expect(null).assertFail(); 1837 } catch (e) { 1838 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 1839 expect(e.code == 401).assertTrue(); 1840 } 1841 query = null; 1842 done(); 1843 }) 1844 1845 /** 1846 * @tc.name: QueryDeviceIdSucTest 1847 * @tc.desc: Test Js Api Query.DeviceId() successfully 1848 * @tc.type: FUNC 1849 * @tc.require: issueNumber 1850 */ 1851 it('QueryDeviceIdSucTest', 0, async function (done) { 1852 var query = null; 1853 try { 1854 query = new ddm.Query(); 1855 expect("").assertEqual(query.getSqlLike()); 1856 query.deviceId("$.name"); 1857 query.deviceId("0"); 1858 expect(query.getSqlLike() !== "").assertTrue(); 1859 console.info("query is " + query.getSqlLike()); 1860 } catch (e) { 1861 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1862 expect(null).assertFail(); 1863 } 1864 query = null; 1865 done(); 1866 }) 1867 1868 /** 1869 * @tc.name: QueryDeviceIdInvalidMoreArgsTest 1870 * @tc.desc: Test Js Api Query.DeviceId() with invalid more args 1871 * @tc.type: FUNC 1872 * @tc.require: issueNumber 1873 */ 1874 it('QueryDeviceIdInvalidMoreArgsTest', 0, async function (done) { 1875 var query = null; 1876 try { 1877 query = new ddm.Query(); 1878 expect("").assertEqual(query.getSqlLike()); 1879 query.deviceId("k", "any"); 1880 console.info("should not throw exception on invalid arguments"); 1881 expect(query.getSqlLike() !== "").assertTrue(); 1882 } catch (e) { 1883 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 1884 expect(null).assertFail(); 1885 } 1886 query = null; 1887 done(); 1888 }) 1889 1890 /** 1891 * @tc.name: QueryDeviceIdInvalidTypeArgsTest 1892 * @tc.desc: Test Js Api Query.DeviceId() with invalid type args 1893 * @tc.type: FUNC 1894 * @tc.require: issueNumber 1895 */ 1896 it('QueryDeviceIdInvalidTypeArgsTest', 0, async function (done) { 1897 var query = null; 1898 try { 1899 query = new ddm.Query(); 1900 expect("").assertEqual(query.getSqlLike()); 1901 query.deviceId(123); 1902 console.info("should throw exception on invalid arguments"); 1903 expect(null).assertFail(); 1904 } catch (e) { 1905 console.error("throw exception is ok : " + `, error code is ${e.code}, message is ${e.message}`); 1906 expect(e.code == 401).assertTrue(); 1907 } 1908 query = null; 1909 done(); 1910 }) 1911 1912 /** 1913 * @tc.name: QueryGetSqlLikeSucTest 1914 * @tc.desc: Test Js Api Query.GetSqlLike() successfully 1915 * @tc.type: FUNC 1916 * @tc.require: issueNumber 1917 */ 1918 it('QueryGetSqlLikeSucTest', 0, async function (done) { 1919 var query = null; 1920 try { 1921 query = new ddm.Query(); 1922 expect("").assertEqual(query.getSqlLike()); 1923 let sql1 = query.getSqlLike(); 1924 console.info("QueryGetSqlLikeSucTest sql=" + sql1); 1925 let sql2 = query.getSqlLike(); 1926 expect(sql1).assertEqual(sql2); 1927 console.info("query is " + query.getSqlLike()); 1928 } catch (e) { 1929 console.error("dumplicated calls should be ok : " + `, error code is ${e.code}, message is ${e.message}`); 1930 expect(null).assertFail(); 1931 } 1932 query = null; 1933 done(); 1934 }) 1935 1936 /** 1937 * @tc.name: QueryGetSqlLikeInvalidMoreArgsTest 1938 * @tc.desc: Test Js Api Query.GetSqlLike() with invalid more args 1939 * @tc.type: FUNC 1940 * @tc.require: issueNumber 1941 */ 1942 it('QueryGetSqlLikeInvalidMoreArgsTest', 0, async function (done) { 1943 var query = null; 1944 try { 1945 query = new ddm.Query(); 1946 expect("").assertEqual(query.getSqlLike()); 1947 query.inNumber("key"); 1948 query.getSqlLike(0); 1949 console.info("should throw exception on invalid arguments"); 1950 expect(null).assertFail(); 1951 } catch (e) { 1952 console.error("throw exception : " + `, error code is ${e.code}, message is ${e.message}`); 1953 expect(e.code == 401).assertTrue(); 1954 } 1955 query = null; 1956 done(); 1957 }) 1958}) 1959