Grcov report - test

1

#![allow(clippy::missing_panics_doc)]

2

3

use std::borrow::Cow;

4

use std::fmt::{Debug, Display};

5

use std::io::ErrorKind;

6

use std::ops::Deref;

7

use std::path::{Path, PathBuf};

8

use std::sync::atomic::{AtomicU32, Ordering};

9

use std::sync::Arc;

10

use std::time::{Duration, Instant};

11

12

use itertools::Itertools;

13

use serde::{Deserialize, Serialize};

14

use transmog_pot::Pot;

15

16

use crate::admin::{PermissionGroup, Role, User};

17

use crate::connection::{

18

    AccessPolicy, AsyncConnection, AsyncStorageConnection, Connection, StorageConnection,

19

};

20

use crate::document::{

21

    BorrowedDocument, CollectionDocument, CollectionHeader, DocumentId, Emit, Header, KeyId,

22

};

23

use crate::keyvalue::{AsyncKeyValue, KeyValue};

24

use crate::limits::{LIST_TRANSACTIONS_DEFAULT_RESULT_COUNT, LIST_TRANSACTIONS_MAX_RESULTS};

25

use crate::schema::view::map::{Mappings, ViewMappedValue};

26

use crate::schema::view::{MapReduce, ReduceResult, SerializedView, ViewUpdatePolicy};

27

use crate::schema::{

28

    Collection, CollectionName, MappedValue, NamedCollection, Qualified, Schema, SchemaName,

29

    Schematic, SerializedCollection, View, ViewMapResult, ViewSchema,

30

};

31

use crate::transaction::{Operation, OperationResult, Transaction};

32

use crate::Error;

33

#[cfg(feature = "token-authentication")]

34

use crate::{

35

    admin::AuthenticationToken,

36

    connection::{HasSession, Identity, IdentityReference, Session},

37

};

38

39

5128210

#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Default, Clone, Collection)]

40

// This collection purposely uses names with characters that need

41

// escaping, since it's used in backup/restore.

42

#[collection(name = "_basic", authority = "khonsulabs_", views = [BasicCount, BasicByParentId, BasicByParentIdEager, BasicByTag, BasicByCategory, BasicByCategoryCow], core = crate)]

43

#[must_use]

44

pub struct Basic {

45

    pub value: String,

46

    pub category: Option<String>,

47

    pub parent_id: Option<u64>,

48

    pub tags: Vec<String>,

49

50

51

impl Basic {

52

3285

    pub fn new(value: impl Into<String>) -> Self {

53

3285

        Self {

54

3285

            value: value.into(),

55

3285

            tags: Vec::default(),

56

3285

            category: None,

57

3285

            parent_id: None,

58

3285

59

3285

60

61

43

    pub fn with_category(mut self, category: impl Into<String>) -> Self {

62

43

        self.category = Some(category.into());

63

43

        self

64

43

65

66

32

    pub fn with_tag(mut self, tag: impl Into<String>) -> Self {

67

32

        self.tags.push(tag.into());

68

32

        self

69

32

70

71

22520

    pub const fn with_parent_id(mut self, parent_id: u64) -> Self {

72

22520

        self.parent_id = Some(parent_id);

73

22520

        self

74

22520

75

76

77

2714003

#[derive(Debug, Clone, View, ViewSchema)]

78

#[view(collection = Basic, key = (), value = usize, name = "count", core = crate)]

79

#[view_schema(core = crate)]

80

pub struct BasicCount;

81

82

impl MapReduce for BasicCount {

83

40

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

84

40

        document.header.emit_key_and_value((), 1)

85

40

86

87

40

    fn reduce(

88

40

        &self,

89

40

        mappings: &[ViewMappedValue<'_, Self>],

90

40

        _rereduce: bool,

91

40

    ) -> ReduceResult<Self::View> {

92

40

        Ok(mappings.iter().map(|map| map.value).sum())

93

40

94

95

96

2767041

#[derive(Debug, Clone, View)]

97

#[view(collection = Basic, key = Option<u64>, value = usize, name = "by-parent-id", core = crate)]

98

pub struct BasicByParentId;

99

100

impl ViewSchema for BasicByParentId {

101

    type MappedKey<'doc> = <Self::View as View>::Key;

102

    type View = Self;

103

104

3920

    fn version(&self) -> u64 {

105

3920

106

3920

107

108

109

impl MapReduce for BasicByParentId {

110

4200

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

111

4200

        let contents = Basic::document_contents(document)?;

112

4200

        document.header.emit_key_and_value(contents.parent_id, 1)

113

4200

114

115

5160

    fn reduce(

116

5160

        &self,

117

5160

        mappings: &[ViewMappedValue<'_, Self>],

118

5160

        _rereduce: bool,

119

5160

    ) -> ReduceResult<Self::View> {

120

5160

        Ok(mappings.iter().map(|map| map.value).sum())

121

5160

122

123

124

3264841

#[derive(Debug, Clone, View, ViewSchema)]

125

#[view(collection = Basic, key = Option<u64>, value = usize, name = "by-parent-id-eager", core = crate)]

126

#[view_schema(core = crate, version = 1, policy = Eager)]

127

pub struct BasicByParentIdEager;

128

129

impl MapReduce for BasicByParentIdEager {

130

495040

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

131

495040

        let contents = Basic::document_contents(document)?;

132

495040

        document.header.emit_key_and_value(contents.parent_id, 1)

133

495040

134

135

496000

    fn reduce(

136

496000

        &self,

137

496000

        mappings: &[ViewMappedValue<'_, Self>],

138

496000

        _rereduce: bool,

139

496000

    ) -> ReduceResult<Self::View> {

140

160862800

        Ok(mappings.iter().map(|map| map.value).sum())

141

496000

142

143

144

2715921

#[derive(Debug, Clone, View, ViewSchema)]

145

#[view(collection = Basic, key = String, value = usize, name = "by-category", core = crate)]

146

#[view_schema(core = crate)]

147

pub struct BasicByCategory;

148

149

impl MapReduce for BasicByCategory {

150

1640

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

151

1640

        let contents = Basic::document_contents(document)?;

152

1640

        if let Some(category) = &contents.category {

153

960

            document

154

960

                .header

155

960

                .emit_key_and_value(category.to_lowercase(), 1)

156

        } else {

157

680

            Ok(Mappings::none())

158

159

1640

160

161

640

    fn reduce(

162

640

        &self,

163

640

        mappings: &[ViewMappedValue<'_, Self>],

164

640

        _rereduce: bool,

165

640

    ) -> ReduceResult<Self::View> {

166

960

        Ok(mappings.iter().map(|map| map.value).sum())

167

640

168

169

170

2715441

#[derive(Debug, Clone, View, ViewSchema)]

171

#[view(collection = Basic, key = String, value = usize, name = "by-category-cow", core = crate)]

172

#[view_schema(core = crate, mapped_key = Cow<'doc, str>)]

173

pub struct BasicByCategoryCow;

174

175

impl MapReduce for BasicByCategoryCow {

176

160

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

177

960

        #[derive(Deserialize, Debug)]

178

        struct BorrowedBasic<'a> {

179

            category: Option<&'a str>,

180

181

160

        let contents: BorrowedBasic<'_> = pot::from_slice(&document.contents)?;

182

160

        if let Some(category) = &contents.category {

183

120

            document

184

120

                .header

185

120

                .emit_key_and_value(Cow::Borrowed(category), 1)

186

        } else {

187

40

            Ok(Mappings::none())

188

189

160

190

191

120

    fn reduce(

192

120

        &self,

193

120

        mappings: &[ViewMappedValue<'_, Self>],

194

120

        _rereduce: bool,

195

120

    ) -> ReduceResult<Self::View> {

196

120

        Ok(mappings

197

120

            .iter()

198

120

            .map(|map| {

199

120

                assert!(matches!(map.key, Cow::Borrowed(_)));

200

120

                map.value

201

120

})

202

120

            .sum())

203

120

204

205

206

2733201

#[derive(Debug, Clone, View, ViewSchema)]

207

#[view(collection = Basic, key = String, value = usize, name = "by-tag", core = crate)]

208

#[view_schema(core = crate)]

209

pub struct BasicByTag;

210

211

impl MapReduce for BasicByTag {

212

1320

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

213

1320

        let contents = Basic::document_contents(document)?;

214

1320

        contents

215

1320

            .tags

216

1320

            .iter()

217

1920

            .map(|tag| document.header.emit_key_and_value(tag.clone(), 1))

218

1320

            .collect()

219

1320

220

221

2240

    fn reduce(

222

2240

        &self,

223

2240

        mappings: &[ViewMappedValue<'_, Self>],

224

2240

        _rereduce: bool,

225

2240

    ) -> ReduceResult<Self::View> {

226

2880

        Ok(mappings.iter().map(|map| map.value).sum())

227

2240

228

229

230

480

#[derive(Debug, Clone, View, ViewSchema)]

231

#[view(collection = Basic, key = (), value = (), name = "by-parent-id", core = crate)]

232

#[view_schema(core = crate)]

233

pub struct BasicByBrokenParentId;

234

235

impl MapReduce for BasicByBrokenParentId {

236

40

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

237

40

        document.header.emit()

238

40

239

240

241

3348880

#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Default, Clone, Collection)]

242

#[collection(name = "encrypted-basic", authority = "khonsulabs", views = [EncryptedBasicCount, EncryptedBasicByParentId, EncryptedBasicByCategory])]

243

#[collection(encryption_key = Some(KeyId::Master), encryption_optional, core = crate)]

244

#[must_use]

245

pub struct EncryptedBasic {

246

    pub value: String,

247

    pub category: Option<String>,

248

    pub parent_id: Option<u64>,

249

250

251

impl EncryptedBasic {

252

1

    pub fn new(value: impl Into<String>) -> Self {

253

1

        Self {

254

1

            value: value.into(),

255

1

            category: None,

256

1

            parent_id: None,

257

1

258

1

259

260

    pub fn with_category(mut self, category: impl Into<String>) -> Self {

261

        self.category = Some(category.into());

262

        self

263

264

265

    pub const fn with_parent_id(mut self, parent_id: u64) -> Self {

266

        self.parent_id = Some(parent_id);

267

        self

268

269

270

271

1675160

#[derive(Debug, Clone, View, ViewSchema)]

272

#[view(collection = EncryptedBasic, key = (), value = usize, name = "count", core = crate)]

273

#[view_schema(core = crate)]

274

pub struct EncryptedBasicCount;

275

276

impl MapReduce for EncryptedBasicCount {

277

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

278

        document.header.emit_key_and_value((), 1)

279

280

281

    fn reduce(

282

        &self,

283

        mappings: &[ViewMappedValue<'_, Self>],

284

        _rereduce: bool,

285

    ) -> ReduceResult<Self::View> {

286

        Ok(mappings.iter().map(|map| map.value).sum())

287

288

289

290

1675160

#[derive(Debug, Clone, View, ViewSchema)]

291

#[view(collection = EncryptedBasic, key = Option<u64>, value = usize, name = "by-parent-id", core = crate)]

292

#[view_schema(core = crate)]

293

pub struct EncryptedBasicByParentId;

294

295

impl MapReduce for EncryptedBasicByParentId {

296

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

297

        let contents = EncryptedBasic::document_contents(document)?;

298

        document.header.emit_key_and_value(contents.parent_id, 1)

299

300

301

    fn reduce(

302

        &self,

303

        mappings: &[ViewMappedValue<'_, Self>],

304

        _rereduce: bool,

305

    ) -> ReduceResult<Self::View> {

306

        Ok(mappings.iter().map(|map| map.value).sum())

307

308

309

310

1675160

#[derive(Debug, Clone, View, ViewSchema)]

311

#[view(collection = EncryptedBasic, key = String, value = usize, name = "by-category", core = crate)]

312

#[view_schema(core = crate)]

313

pub struct EncryptedBasicByCategory;

314

315

impl MapReduce for EncryptedBasicByCategory {

316

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

317

        let contents = EncryptedBasic::document_contents(document)?;

318

        if let Some(category) = &contents.category {

319

            document

320

                .header

321

                .emit_key_and_value(category.to_lowercase(), 1)

322

        } else {

323

            Ok(Mappings::none())

324

325

326

327

    fn reduce(

328

        &self,

329

        mappings: &[ViewMappedValue<'_, Self>],

330

        _rereduce: bool,

331

    ) -> ReduceResult<Self::View> {

332

        Ok(mappings.iter().map(|map| map.value).sum())

333

334

335

336

1674440

#[derive(Debug, Schema)]

337

#[schema(name = "basic", collections = [Basic, EncryptedBasic, Unique], core = crate)]

338

pub struct BasicSchema;

339

340

1674440

#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq, Default, Collection)]

341

#[collection(name = "unique", authority = "khonsulabs", views = [UniqueValue], core = crate)]

342

pub struct Unique {

343

    pub value: String,

344

345

346

impl Unique {

347

40

    pub fn new(value: impl Display) -> Self {

348

40

        Self {

349

40

            value: value.to_string(),

350

40

351

40

352

353

354

1693000

#[derive(Debug, Clone, View, ViewSchema)]

355

#[view(collection = Unique, key = String, value = (), name = "unique-value", core = crate)]

356

#[view_schema(core = crate, policy = Unique)]

357

pub struct UniqueValue;

358

359

impl MapReduce for UniqueValue {

360

2560

    fn map<'doc>(&self, document: &'doc BorrowedDocument<'_>) -> ViewMapResult<'doc, Self> {

361

2560

        let entry = Unique::document_contents(document)?;

362

2560

        document.header.emit_key(entry.value)

363

2560

364

365

366

impl NamedCollection for Unique {

367

    type ByNameView = UniqueValue;

368

369

370

#[derive(Debug)]

371

pub struct TestDirectory(pub PathBuf);

372

373

impl TestDirectory {

374

5

    pub fn absolute<S: AsRef<Path>>(path: S) -> Self {

375

5

        let path = path.as_ref().to_owned();

376

5

        if path.exists() {

377

            std::fs::remove_dir_all(&path).expect("error clearing temporary directory");

378

5

379

5

        Self(path)

380

5

381

382

221

    pub fn new<S: AsRef<Path>>(name: S) -> Self {

383

221

        let path = std::env::temp_dir().join(name);

384

221

        if path.exists() {

385

            std::fs::remove_dir_all(&path).expect("error clearing temporary directory");

386

221

387

221

        Self(path)

388

221

389

390

391

impl Drop for TestDirectory {

392

    fn drop(&mut self) {

393

8960

        if let Err(err) = std::fs::remove_dir_all(&self.0) {

394

            if err.kind() != ErrorKind::NotFound {

395

                eprintln!("Failed to clean up temporary folder: {err:?}");

396

397

8960

398

8960

399

400

401

impl AsRef<Path> for TestDirectory {

402

9680

    fn as_ref(&self) -> &Path {

403

9680

        &self.0

404

9680

405

406

407

impl Deref for TestDirectory {

408

    type Target = PathBuf;

409

410

40

    fn deref(&self) -> &Self::Target {

411

40

        &self.0

412

40

413

414

415

#[derive(Debug)]

416

pub struct BasicCollectionWithNoViews;

417

418

impl Collection for BasicCollectionWithNoViews {

419

    type PrimaryKey = u64;

420

421

320

    fn collection_name() -> CollectionName {

422

320

        Basic::collection_name()

423

320

424

425

80

    fn define_views(_schema: &mut Schematic) -> Result<(), Error> {

426

80

        Ok(())

427

80

428

429

430

impl SerializedCollection for BasicCollectionWithNoViews {

431

    type Contents = Basic;

432

    type Format = Pot;

433

434

40

    fn format() -> Self::Format {

435

40

        Pot::default()

436

40

437

438

439

#[derive(Debug)]

440

pub struct BasicCollectionWithOnlyBrokenParentId;

441

442

impl Collection for BasicCollectionWithOnlyBrokenParentId {

443

    type PrimaryKey = u64;

444

445

280

    fn collection_name() -> CollectionName {

446

280

        Basic::collection_name()

447

280

448

449

80

    fn define_views(schema: &mut Schematic) -> Result<(), Error> {

450

80

        schema.define_view(BasicByBrokenParentId)

451

80

452

453

454

640

#[derive(Serialize, Deserialize, Clone, Debug, Collection)]

455

#[collection(name = "unassociated", authority = "khonsulabs", core = crate)]

456

pub struct UnassociatedCollection;

457

458

11320

#[derive(Copy, Clone, Debug)]

459

pub enum HarnessTest {

460

    ServerConnectionTests = 1,

461

    StoreRetrieveUpdate,

462

    Overwrite,

463

    NotFound,

464

    Conflict,

465

    BadUpdate,

466

    NoUpdate,

467

    GetMultiple,

468

    List,

469

    ListTransactions,

470

    Transactions,

471

    TransactionCheck,

472

    ViewQuery,

473

    UnassociatedCollection,

474

    Compact,

475

    ViewUpdate,

476

    ViewMultiEmit,

477

    ViewUnimplementedReduce,

478

    ViewAccessPolicies,

479

    ViewCow,

480

    Encryption,

481

    UniqueViews,

482

    NamedCollection,

483

    PubSubSimple,

484

    UserManagement,

485

    TokenAuthentication,

486

    PubSubMultipleSubscribers,

487

    PubSubDropAndSend,

488

    PubSubUnsubscribe,

489

    PubSubDropCleanup,

490

    PubSubPublishAll,

491

    KvBasic,

492

    KvConcurrency,

493

    KvSet,

494

    KvIncrementDecrement,

495

    KvExpiration,

496

    KvDeleteExpire,

497

    KvTransactions,

498

499

500

impl HarnessTest {

501

    #[must_use]

502

    pub const fn port(self, base: u16) -> u16 {

503

        base + self as u16

504

505

506

507

impl Display for HarnessTest {

508

11320

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

509

11320

        Debug::fmt(&self, f)

510

11320

511

512

513

/// Compares two f64's accounting for the epsilon.

514

#[macro_export]

515

macro_rules! assert_f64_eq {

516

    ($a:expr, $b:expr) => {{

517

        let a: f64 = $a;

518

        let b: f64 = $b;

519

        assert!((a - b).abs() <= f64::EPSILON, "{:?} <> {:?}", a, b);

520

}};

521

522

523

/// Creates a test suite that tests methods available on [`AsyncConnection`]

524

#[macro_export]

525

macro_rules! define_async_connection_test_suite {

526

    ($harness:ident) => {

527

        #[cfg(test)]

528

        mod r#async_connection {

529

            use super::$harness;

530

            #[tokio::test]

531

5

            async fn server_connection_tests() -> anyhow::Result<()> {

532

5

                let harness =

533

5

                    $harness::new($crate::test_util::HarnessTest::ServerConnectionTests).await?;

534

5

                let db = harness.server();

535

5

                $crate::test_util::basic_server_connection_tests(

536

5

                    db.clone(),

537

5

                    &format!("server-connection-tests-{}", $harness::server_name()),

538

5

539

5

                .await?;

540

5

                harness.shutdown().await

541

5

542

543

            #[tokio::test]

544

5

            async fn store_retrieve_update_delete() -> anyhow::Result<()> {

545

5

                let harness =

546

5

                    $harness::new($crate::test_util::HarnessTest::StoreRetrieveUpdate).await?;

547

5

                let db = harness.connect().await?;

548

5

                $crate::test_util::store_retrieve_update_delete_tests(&db).await?;

549

5

                harness.shutdown().await

550

5

551

552

            #[tokio::test]

553

5

            async fn overwrite() -> anyhow::Result<()> {

554

5

                let harness = $harness::new($crate::test_util::HarnessTest::Overwrite).await?;

555

5

                let db = harness.connect().await?;

556

5

                $crate::test_util::overwrite_tests(&db).await?;

557

5

                harness.shutdown().await

558

5

559

560

            #[tokio::test]

561

5

            async fn not_found() -> anyhow::Result<()> {

562

5

                let harness = $harness::new($crate::test_util::HarnessTest::NotFound).await?;

563

5

                let db = harness.connect().await?;

564

5

565

5

                $crate::test_util::not_found_tests(&db).await?;

566

5

                harness.shutdown().await

567

5

568

569

            #[tokio::test]

570

5

            async fn conflict() -> anyhow::Result<()> {

571

5

                let harness = $harness::new($crate::test_util::HarnessTest::Conflict).await?;

572

5

                let db = harness.connect().await?;

573

5

574

5

                $crate::test_util::conflict_tests(&db).await?;

575

5

                harness.shutdown().await

576

5

577

578

            #[tokio::test]

579

5

            async fn bad_update() -> anyhow::Result<()> {

580

5

                let harness = $harness::new($crate::test_util::HarnessTest::BadUpdate).await?;

581

5

                let db = harness.connect().await?;

582

5

583

5

                $crate::test_util::bad_update_tests(&db).await?;

584

5

                harness.shutdown().await

585

5

586

587

            #[tokio::test]

588

5

            async fn no_update() -> anyhow::Result<()> {

589

5

                let harness = $harness::new($crate::test_util::HarnessTest::NoUpdate).await?;

590

5

                let db = harness.connect().await?;

591

5

592

5

                $crate::test_util::no_update_tests(&db).await?;

593

5

                harness.shutdown().await

594

5

595

596

            #[tokio::test]

597

5

            async fn get_multiple() -> anyhow::Result<()> {

598

5

                let harness = $harness::new($crate::test_util::HarnessTest::GetMultiple).await?;

599

5

                let db = harness.connect().await?;

600

5

601

5

                $crate::test_util::get_multiple_tests(&db).await?;

602

5

                harness.shutdown().await

603

5

604

605

            #[tokio::test]

606

5

            async fn list() -> anyhow::Result<()> {

607

5

                let harness = $harness::new($crate::test_util::HarnessTest::List).await?;

608

5

                let db = harness.connect().await?;

609

5

610

5

                $crate::test_util::list_tests(&db).await?;

611

5

                harness.shutdown().await

612

5

613

614

            #[tokio::test]

615

5

            async fn list_transactions() -> anyhow::Result<()> {

616

5

                let harness =

617

5

                    $harness::new($crate::test_util::HarnessTest::ListTransactions).await?;

618

5

                let db = harness.connect().await?;

619

5

620

5

                $crate::test_util::list_transactions_tests(&db).await?;

621

5

                harness.shutdown().await

622

5

623

624

            #[tokio::test]

625

5

            async fn transactions() -> anyhow::Result<()> {

626

5

                let harness = $harness::new($crate::test_util::HarnessTest::Transactions).await?;

627

5

                let db = harness.connect().await?;

628

5

629

5

                $crate::test_util::transaction_tests(&db).await?;

630

5

                harness.shutdown().await

631

5

632

633

            #[tokio::test]

634

5

            async fn transaction_check() -> anyhow::Result<()> {

635

5

                let harness =

636

5

                    $harness::new($crate::test_util::HarnessTest::TransactionCheck).await?;

637

5

                let db = harness.connect().await?;

638

5

639

5

                $crate::test_util::transaction_check_tests(&db).await?;

640

5

                harness.shutdown().await

641

5

642

643

            #[tokio::test]

644

5

            async fn view_query() -> anyhow::Result<()> {

645

5

                let harness = $harness::new($crate::test_util::HarnessTest::ViewQuery).await?;

646

5

                let db = harness.connect().await?;

647

5

648

5

                $crate::test_util::view_query_tests(&db).await?;

649

5

                harness.shutdown().await

650

5

651

652

            #[tokio::test]

653

5

            async fn unassociated_collection() -> anyhow::Result<()> {

654

5

                let harness =

655

5

                    $harness::new($crate::test_util::HarnessTest::UnassociatedCollection).await?;

656

5

                let db = harness.connect().await?;

657

5

658

5

                $crate::test_util::unassociated_collection_tests(&db).await?;

659

5

                harness.shutdown().await

660

5

661

662

            #[tokio::test]

663

5

            async fn unimplemented_reduce() -> anyhow::Result<()> {

664

5

                let harness =

665

5

                    $harness::new($crate::test_util::HarnessTest::ViewUnimplementedReduce).await?;

666

5

                let db = harness.connect().await?;

667

5

668

5

                $crate::test_util::unimplemented_reduce(&db).await?;

669

5

                harness.shutdown().await

670

5

671

672

            #[tokio::test]

673

5

            async fn view_update() -> anyhow::Result<()> {

674

5

                let harness = $harness::new($crate::test_util::HarnessTest::ViewUpdate).await?;

675

5

                let db = harness.connect().await?;

676

5

677

5

                $crate::test_util::view_update_tests(&db).await?;

678

5

                harness.shutdown().await

679

5

680

681

            #[tokio::test]

682

5

            async fn view_multi_emit() -> anyhow::Result<()> {

683

5

                let harness = $harness::new($crate::test_util::HarnessTest::ViewMultiEmit).await?;

684

5

                let db = harness.connect().await?;

685

5

686

5

                $crate::test_util::view_multi_emit_tests(&db).await?;

687

5

                harness.shutdown().await

688

5

689

690

            #[tokio::test]

691

5

            async fn view_access_policies() -> anyhow::Result<()> {

692

5

                let harness =

693

5

                    $harness::new($crate::test_util::HarnessTest::ViewAccessPolicies).await?;

694

5

                let db = harness.connect().await?;

695

5

696

5

                $crate::test_util::view_access_policy_tests(&db).await?;

697

5

                harness.shutdown().await

698

5

699

700

            #[tokio::test]

701

5

            async fn unique_views() -> anyhow::Result<()> {

702

5

                let harness = $harness::new($crate::test_util::HarnessTest::UniqueViews).await?;

703

5

                let db = harness.connect().await?;

704

5

705

5

                $crate::test_util::unique_view_tests(&db).await?;

706

5

                harness.shutdown().await

707

5

708

709

            #[tokio::test]

710

5

            async fn named_collection() -> anyhow::Result<()> {

711

5

                let harness =

712

5

                    $harness::new($crate::test_util::HarnessTest::NamedCollection).await?;

713

5

                let db = harness.connect().await?;

714

5

715

5

                $crate::test_util::named_collection_tests(&db).await?;

716

5

                harness.shutdown().await

717

5

718

719

            #[tokio::test]

720

5

            async fn user_management() -> anyhow::Result<()> {

721

5

                use $crate::connection::AsyncStorageConnection;

722

5

                let harness = $harness::new($crate::test_util::HarnessTest::UserManagement).await?;

723

5

                let _db = harness.connect().await?;

724

5

                let server = harness.server();

725

5

                let admin = server

726

5

                    .database::<$crate::admin::Admin>($crate::admin::ADMIN_DATABASE_NAME)

727

5

                    .await?;

728

5

729

5

                $crate::test_util::user_management_tests(

730

5

                    &admin,

731

5

                    server.clone(),

732

5

                    $harness::server_name(),

733

5

734

5

                .await?;

735

5

                harness.shutdown().await

736

5

737

738

            #[tokio::test]

739

            #[cfg(feature = "token-authentication")]

740

5

            async fn token_authentication() -> anyhow::Result<()> {

741

5

                use $crate::connection::AsyncStorageConnection;

742

5

                let harness =

743

5

                    $harness::new($crate::test_util::HarnessTest::TokenAuthentication).await?;

744

5

                let _db = harness.connect().await?;

745

5

                let server = harness.server();

746

5

                let admin = server

747

5

                    .database::<$crate::admin::Admin>($crate::admin::ADMIN_DATABASE_NAME)

748

5

                    .await?;

749

5

750

5

                $crate::test_util::token_authentication_tests(

751

5

                    &admin,

752

5

                    server,

753

5

                    $harness::server_name(),

754

5

755

5

                .await?;

756

5

                harness.shutdown().await

757

5

758

759

            #[tokio::test]

760

5

            async fn compaction() -> anyhow::Result<()> {

761

5

                let harness = $harness::new($crate::test_util::HarnessTest::Compact).await?;

762

5

                let db = harness.connect().await?;

763

5

764

5

                $crate::test_util::compaction_tests(&db).await?;

765

5

                harness.shutdown().await

766

5

767

768

};

769

770

771

/// Creates a test suite that tests methods available on [`AsyncConnection`]

772

#[macro_export]

773

macro_rules! define_blocking_connection_test_suite {

774

    ($harness:ident) => {

775

        #[cfg(test)]

776

        mod blocking_connection {

777

            use super::$harness;

778

            #[test]

779

3

            fn server_connection_tests() -> anyhow::Result<()> {

780

3

                let harness = $harness::new($crate::test_util::HarnessTest::ServerConnectionTests)?;

781

3

                let db = harness.server();

782

3

                $crate::test_util::blocking_basic_server_connection_tests(

783

3

db,

784

3

                    &format!("server-connection-tests-{}", $harness::server_name()),

785

3

)?;

786

3

                harness.shutdown()

787

3

788

789

            #[test]

790

3

            fn store_retrieve_update_delete() -> anyhow::Result<()> {

791

3

                let harness = $harness::new($crate::test_util::HarnessTest::StoreRetrieveUpdate)?;

792

3

                let db = harness.connect()?;

793

3

                $crate::test_util::blocking_store_retrieve_update_delete_tests(&db)?;

794

3

                harness.shutdown()

795

3

796

797

            #[test]

798

3

            fn overwrite() -> anyhow::Result<()> {

799

3

                let harness = $harness::new($crate::test_util::HarnessTest::Overwrite)?;

800

3

                let db = harness.connect()?;

801

3

                $crate::test_util::blocking_overwrite_tests(&db)?;

802

3

                harness.shutdown()

803

3

804

805

            #[test]

806

3

            fn not_found() -> anyhow::Result<()> {

807

3

                let harness = $harness::new($crate::test_util::HarnessTest::NotFound)?;

808

3

                let db = harness.connect()?;

809

810

3

                $crate::test_util::blocking_not_found_tests(&db)?;

811

3

                harness.shutdown()

812

3

813

814

            #[test]

815

3

            fn conflict() -> anyhow::Result<()> {

816

3

                let harness = $harness::new($crate::test_util::HarnessTest::Conflict)?;

817

3

                let db = harness.connect()?;

818

819

3

                $crate::test_util::blocking_conflict_tests(&db)?;

820

3

                harness.shutdown()

821

3

822

823

            #[test]

824

3

            fn bad_update() -> anyhow::Result<()> {

825

3

                let harness = $harness::new($crate::test_util::HarnessTest::BadUpdate)?;

826

3

                let db = harness.connect()?;

827

828

3

                $crate::test_util::blocking_bad_update_tests(&db)?;

829

3

                harness.shutdown()

830

3

831

832

            #[test]

833

3

            fn no_update() -> anyhow::Result<()> {

834

3

                let harness = $harness::new($crate::test_util::HarnessTest::NoUpdate)?;

835

3

                let db = harness.connect()?;

836

837

3

                $crate::test_util::blocking_no_update_tests(&db)?;

838

3

                harness.shutdown()

839

3

840

841

            #[test]

842

3

            fn get_multiple() -> anyhow::Result<()> {

843

3

                let harness = $harness::new($crate::test_util::HarnessTest::GetMultiple)?;

844

3

                let db = harness.connect()?;

845

846

3

                $crate::test_util::blocking_get_multiple_tests(&db)?;

847

3

                harness.shutdown()

848

3

849

850

            #[test]

851

3

            fn list() -> anyhow::Result<()> {

852

3

                let harness = $harness::new($crate::test_util::HarnessTest::List)?;

853

3

                let db = harness.connect()?;

854

855

3

                $crate::test_util::blocking_list_tests(&db)?;

856

3

                harness.shutdown()

857

3

858

859

            #[test]

860

3

            fn list_transactions() -> anyhow::Result<()> {

861

3

                let harness = $harness::new($crate::test_util::HarnessTest::ListTransactions)?;

862

3

                let db = harness.connect()?;

863

864

3

                $crate::test_util::blocking_list_transactions_tests(&db)?;

865

3

                harness.shutdown()

866

3

867

868

            #[test]

869

3

            fn transaction_check() -> anyhow::Result<()> {

870

3

                let harness = $harness::new($crate::test_util::HarnessTest::TransactionCheck)?;

871

3

                let db = harness.connect()?;

872

873

3

                $crate::test_util::blocking_transaction_check_tests(&db)?;

874

3

                harness.shutdown()

875

3

876

877

            #[test]

878

3

            fn transactions() -> anyhow::Result<()> {

879

3

                let harness = $harness::new($crate::test_util::HarnessTest::Transactions)?;

880

3

                let db = harness.connect()?;

881

882

3

                $crate::test_util::blocking_transaction_tests(&db)?;

883

3

                harness.shutdown()

884

3

885

886

            #[test]

887

3

            fn view_query() -> anyhow::Result<()> {

888

3

                let harness = $harness::new($crate::test_util::HarnessTest::ViewQuery)?;

889

3

                let db = harness.connect()?;

890

891

3

                $crate::test_util::blocking_view_query_tests(&db)?;

892

3

                harness.shutdown()

893

3

894

895

            #[test]

896

3

            fn unassociated_collection() -> anyhow::Result<()> {

897

3

                let harness =

898

3

                    $harness::new($crate::test_util::HarnessTest::UnassociatedCollection)?;

899

3

                let db = harness.connect()?;

900

901

3

                $crate::test_util::blocking_unassociated_collection_tests(&db)?;

902

3

                harness.shutdown()

903

3

904

905

            #[test]

906

3

            fn unimplemented_reduce() -> anyhow::Result<()> {

907

3

                let harness =

908

3

                    $harness::new($crate::test_util::HarnessTest::ViewUnimplementedReduce)?;

909

3

                let db = harness.connect()?;

910

911

3

                $crate::test_util::blocking_unimplemented_reduce(&db)?;

912

3

                harness.shutdown()

913

3

914

915

            #[test]

916

3

            fn view_update() -> anyhow::Result<()> {

917

3

                let harness = $harness::new($crate::test_util::HarnessTest::ViewUpdate)?;

918

3

                let db = harness.connect()?;

919

920

3

                $crate::test_util::blocking_view_update_tests(&db)?;

921

3

                harness.shutdown()

922

3

923

924

            #[test]

925

3

            fn view_multi_emit() -> anyhow::Result<()> {

926

3

                let harness = $harness::new($crate::test_util::HarnessTest::ViewMultiEmit)?;

927

3

                let db = harness.connect()?;

928

929

3

                $crate::test_util::blocking_view_multi_emit_tests(&db)?;

930

3

                harness.shutdown()

931

3

932

933

            #[test]

934

3

            fn view_access_policies() -> anyhow::Result<()> {

935

3

                let harness = $harness::new($crate::test_util::HarnessTest::ViewAccessPolicies)?;

936

3

                let db = harness.connect()?;

937

938

3

                $crate::test_util::blocking_view_access_policy_tests(&db)?;

939

3

                harness.shutdown()

940

3

941

942

            #[test]

943

3

            fn unique_views() -> anyhow::Result<()> {

944

3

                let harness = $harness::new($crate::test_util::HarnessTest::UniqueViews)?;

945

3

                let db = harness.connect()?;

946

947

3

                $crate::test_util::blocking_unique_view_tests(&db)?;

948

3

                harness.shutdown()

949

3

950

951

            #[test]

952

3

            fn cow_views() -> anyhow::Result<()> {

953

3

                let harness = $harness::new($crate::test_util::HarnessTest::ViewCow)?;

954

3

                let db = harness.connect()?;

955

3

                $crate::test_util::blocking_cow_views(&db)?;

956

3

                harness.shutdown()

957

3

958

959

            #[test]

960

3

            fn named_collection() -> anyhow::Result<()> {

961

3

                let harness = $harness::new($crate::test_util::HarnessTest::NamedCollection)?;

962

3

                let db = harness.connect()?;

963

964

3

                $crate::test_util::blocking_named_collection_tests(&db)?;

965

3

                harness.shutdown()

966

3

967

968

            #[test]

969

3

            fn user_management() -> anyhow::Result<()> {

970

                use $crate::connection::StorageConnection;

971

3

                let harness = $harness::new($crate::test_util::HarnessTest::UserManagement)?;

972

3

                let _db = harness.connect()?;

973

3

                let server = harness.server();

974

3

                let admin =

975

3

                    server.database::<$crate::admin::Admin>($crate::admin::ADMIN_DATABASE_NAME)?;

976

977

3

                $crate::test_util::blocking_user_management_tests(

978

3

                    &admin,

979

3

                    server,

980

3

                    $harness::server_name(),

981

3

)?;

982

3

                harness.shutdown()

983

3

984

985

            #[test]

986

            #[cfg(feature = "token-authentication")]

987

3

            fn token_authentication() -> anyhow::Result<()> {

988

                use $crate::connection::StorageConnection;

989

3

                let harness = $harness::new($crate::test_util::HarnessTest::TokenAuthentication)?;

990

3

                let _db = harness.connect()?;

991

3

                let server = harness.server();

992

3

                let admin =

993

3

                    server.database::<$crate::admin::Admin>($crate::admin::ADMIN_DATABASE_NAME)?;

994

995

3

                $crate::test_util::blocking_token_authentication_tests(

996

3

                    &admin,

997

3

                    server,

998

3

                    $harness::server_name(),

999

3

)?;

1000

3

                harness.shutdown()

1001

3

1002

1003

            #[test]

1004

3

            fn compaction() -> anyhow::Result<()> {

1005

3

                let harness = $harness::new($crate::test_util::HarnessTest::Compact)?;

1006

3

                let db = harness.connect()?;

1007

1008

3

                $crate::test_util::blocking_compaction_tests(&db)?;

1009

3

                harness.shutdown()

1010

3

1011

1012

};

1013

1014

1015

506

pub async fn store_retrieve_update_delete_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1016

506

    let original_value = Basic::new("initial_value");

1017

506

    let collection = db.collection::<Basic>();

1018

4784

    let header = collection.push(&original_value).await?;

1019

1020

506

    let mut doc = collection

1021

506

        .get(&header.id)

1022

2040

        .await?

1023

506

        .expect("couldn't retrieve stored item");

1024

506

    let mut value = Basic::document_contents(&doc)?;

1025

506

    assert_eq!(original_value, value);

1026

506

    let old_revision = doc.header.revision;

1027

506

1028

506

    // Update the value

1029

506

    value.value = String::from("updated_value");

1030

506

    Basic::set_document_contents(&mut doc, value.clone())?;

1031

3599

    db.update::<Basic, _>(&mut doc).await?;

1032

1033

    // update should cause the revision to be changed

1034

506

    assert_ne!(doc.header.revision, old_revision);

1035

1036

    // Check the value in the database to ensure it has the new document

1037

506

    let doc = collection

1038

506

        .get(&header.id)

1039

1546

        .await?

1040

506

        .expect("couldn't retrieve stored item");

1041

506

    assert_eq!(Basic::document_contents(&doc)?, value);

1042

1043

    // These operations should have created two transactions with one change each

1044

1521

    let transactions = db.list_executed_transactions(None, None).await?;

1045

506

    assert_eq!(transactions.len(), 2);

1046

506

    assert!(transactions[0].id < transactions[1].id);

1047

1518

    for transaction in &transactions {

1048

1012

        let changes = transaction

1049

1012

            .changes

1050

1012

            .documents()

1051

1012

            .expect("incorrect transaction type");

1052

1012

        assert_eq!(changes.documents.len(), 1);

1053

1012

        assert_eq!(changes.collections.len(), 1);

1054

1012

        assert_eq!(changes.collections[0], Basic::collection_name());

1055

1012

        assert_eq!(changes.documents[0].collection, 0);

1056

1012

        assert_eq!(header.id, changes.documents[0].id.deserialize()?);

1057

1012

        assert!(!changes.documents[0].deleted);

1058

1059

1060

3151

    db.collection::<Basic>().delete(&doc).await?;

1061

1490

    assert!(collection.get(&header.id).await?.is_none());

1062

506

    let transactions = db

1063

506

        .list_executed_transactions(Some(transactions.last().as_ref().unwrap().id + 1), None)

1064

1415

        .await?;

1065

506

    assert_eq!(transactions.len(), 1);

1066

506

    let transaction = transactions.first().unwrap();

1067

506

    let changes = transaction

1068

506

        .changes

1069

506

        .documents()

1070

506

        .expect("incorrect transaction type");

1071

506

    assert_eq!(changes.documents.len(), 1);

1072

506

    assert_eq!(changes.collections[0], Basic::collection_name());

1073

506

    assert_eq!(header.id, changes.documents[0].id.deserialize()?);

1074

506

    assert!(changes.documents[0].deleted);

1075

1076

    // Use the Collection interface

1077

3116

    let mut doc = original_value.clone().push_into_async(db).await?;

1078

506

    doc.contents.category = Some(String::from("updated"));

1079

3275

    doc.update_async(db).await?;

1080

1467

    let reloaded = Basic::get_async(&doc.header.id, db).await?.unwrap();

1081

506

    assert_eq!(doc.contents, reloaded.contents);

1082

1083

    // Test Connection::insert with a specified id

1084

506

    let doc = BorrowedDocument::with_contents::<Basic, _>(&42, &Basic::new("42"))?;

1085

506

    let document_42 = db

1086

506

        .insert::<Basic, _, _>(Some(&doc.header.id), doc.contents.into_vec())

1087

3216

        .await?;

1088

506

    assert_eq!(document_42.id, 42);

1089

3264

    let document_43 = Basic::new("43").insert_into_async(&43, db).await?;

1090

506

    assert_eq!(document_43.header.id, 43);

1091

1092

    // Test that inserting a document with the same ID results in a conflict:

1093

506

    let conflict_err = Basic::new("43")

1094

506

        .with_parent_id(document_42.id)

1095

506

        .insert_into_async(&doc.header.id, db)

1096

1796

        .await

1097

506

        .unwrap_err();

1098

506

    assert!(matches!(conflict_err.error, Error::DocumentConflict(..)));

1099

1100

    // Test bulk insert

1101

506

    let docs = Basic::push_all_async([Basic::new("44"), Basic::new("45")], db)

1102

4312

        .await

1103

506

        .unwrap();

1104

506

    assert_eq!(docs[0].contents.value, "44");

1105

506

    assert_eq!(docs[1].contents.value, "45");

1106

1107

506

    Ok(())

1108

506

1109

1110

#[allow(clippy::cognitive_complexity)] // TODO should be split into multiple tests

1111

3

pub fn blocking_store_retrieve_update_delete_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

1112

3

    let original_value = Basic::new("initial_value");

1113

3

    let collection = db.collection::<Basic>();

1114

3

    let header = collection.push(&original_value)?;

1115

1116

3

    let mut doc = collection

1117

3

        .get(&header.id)?

1118

3

        .expect("couldn't retrieve stored item");

1119

3

    let mut value = Basic::document_contents(&doc)?;

1120

3

    assert_eq!(original_value, value);

1121

3

    let old_revision = doc.header.revision;

1122

3

1123

3

    // Update the value

1124

3

    value.value = String::from("updated_value");

1125

3

    Basic::set_document_contents(&mut doc, value.clone())?;

1126

3

    db.update::<Basic, _>(&mut doc)?;

1127

1128

    // update should cause the revision to be changed

1129

3

    assert_ne!(doc.header.revision, old_revision);

1130

1131

    // Check the value in the database to ensure it has the new document

1132

3

    let doc = collection

1133

3

        .get(&header.id)?

1134

3

        .expect("couldn't retrieve stored item");

1135

3

    assert_eq!(Basic::document_contents(&doc)?, value);

1136

1137

    // These operations should have created two transactions with one change each

1138

3

    let transactions = db.list_executed_transactions(None, None)?;

1139

3

    assert_eq!(transactions.len(), 2);

1140

3

    assert!(transactions[0].id < transactions[1].id);

1141

9

    for transaction in &transactions {

1142

6

        let changes = transaction

1143

6

            .changes

1144

6

            .documents()

1145

6

            .expect("incorrect transaction type");

1146

6

        assert_eq!(changes.documents.len(), 1);

1147

6

        assert_eq!(changes.collections.len(), 1);

1148

6

        assert_eq!(changes.collections[0], Basic::collection_name());

1149

6

        assert_eq!(changes.documents[0].collection, 0);

1150

6

        assert_eq!(header.id, changes.documents[0].id.deserialize()?);

1151

6

        assert!(!changes.documents[0].deleted);

1152

1153

1154

3

    db.collection::<Basic>().delete(&doc)?;

1155

3

    assert!(collection.get(&header.id)?.is_none());

1156

3

    let transactions =

1157

3

        db.list_executed_transactions(Some(transactions.last().as_ref().unwrap().id + 1), None)?;

1158

3

    assert_eq!(transactions.len(), 1);

1159

3

    let transaction = transactions.first().unwrap();

1160

3

    let changes = transaction

1161

3

        .changes

1162

3

        .documents()

1163

3

        .expect("incorrect transaction type");

1164

3

    assert_eq!(changes.documents.len(), 1);

1165

3

    assert_eq!(changes.collections[0], Basic::collection_name());

1166

3

    assert_eq!(header.id, changes.documents[0].id.deserialize()?);

1167

3

    assert!(changes.documents[0].deleted);

1168

1169

    // Use the Collection interface

1170

3

    let mut doc = original_value.push_into(db)?;

1171

3

    doc.contents.category = Some(String::from("updated"));

1172

3

    doc.update(db)?;

1173

3

    let reloaded = Basic::get(&doc.header.id, db)?.unwrap();

1174

3

    assert_eq!(doc.contents, reloaded.contents);

1175

1176

    // Test Connection::insert with a specified id

1177

3

    let doc = BorrowedDocument::with_contents::<Basic, _>(&42, &Basic::new("42"))?;

1178

3

    let document_42 = db.insert::<Basic, _, _>(Some(&doc.header.id), doc.contents.into_vec())?;

1179

3

    assert_eq!(document_42.id, 42);

1180

3

    let document_43 = Basic::new("43").insert_into(&43, db)?;

1181

3

    assert_eq!(document_43.header.id, 43);

1182

1183

    // Test that inserting a document with the same ID results in a conflict:

1184

3

    let conflict_err = Basic::new("43")

1185

3

        .insert_into(&doc.header.id, db)

1186

3

        .unwrap_err();

1187

3

    assert!(matches!(conflict_err.error, Error::DocumentConflict(..)));

1188

1189

    // Test bulk insert

1190

3

    let docs = Basic::push_all([Basic::new("44"), Basic::new("45")], db).unwrap();

1191

3

    assert_eq!(docs[0].contents.value, "44");

1192

3

    assert_eq!(docs[1].contents.value, "45");

1193

1194

3

    Ok(())

1195

3

1196

1197

5

pub async fn overwrite_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1198

    // Test Connection::insert with a specified id

1199

5

    let doc = BorrowedDocument::with_contents::<Basic, _>(&42, &Basic::new("42"))?;

1200

5

    let document_42 = db

1201

5

        .insert::<Basic, _, _>(Some(&doc.header.id), doc.contents.into_vec())

1202

5

        .await?;

1203

5

    assert_eq!(document_42.id, 42);

1204

5

    let document_43 = Basic::new("43").insert_into_async(&43, db).await?;

1205

5

    assert_eq!(document_43.header.id, 43);

1206

1207

    // Test that overwriting works

1208

5

    let overwritten = Basic::new("43")

1209

5

        .with_parent_id(document_42.id)

1210

5

        .overwrite_into_async(&doc.header.id, db)

1211

5

        .await

1212

5

        .unwrap();

1213

5

    assert!(overwritten.header.revision.id > doc.header.revision.id);

1214

5

    let children = db

1215

5

        .view::<BasicByParentIdEager>()

1216

5

        .with_access_policy(AccessPolicy::NoUpdate)

1217

5

        .with_key(&Some(document_42.id))

1218

5

        .query()

1219

5

        .await?;

1220

5

    assert_eq!(children[0].source.revision, overwritten.header.revision);

1221

1222

    // Verify that unique/eager views are updated when overwriting into a non-existant key

1223

5

    let insert_via_overwrite = Basic::new("1000")

1224

5

        .with_parent_id(document_43.header.id)

1225

5

        .overwrite_into_async(&1_000, db)

1226

5

        .await

1227

5

        .unwrap();

1228

5

    let children = db

1229

5

        .view::<BasicByParentIdEager>()

1230

5

        .with_access_policy(AccessPolicy::NoUpdate)

1231

5

        .with_key(&Some(document_43.header.id))

1232

5

        .query()

1233

5

        .await?;

1234

5

    assert_eq!(

1235

5

        children[0].source.revision,

1236

5

        insert_via_overwrite.header.revision

1237

5

);

1238

1239

5

    Ok(())

1240

5

1241

1242

3

pub fn blocking_overwrite_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

1243

    // Test Connection::insert with a specified id

1244

3

    let doc = BorrowedDocument::with_contents::<Basic, _>(&42, &Basic::new("42"))?;

1245

3

    let document_42 = db.insert::<Basic, _, _>(Some(&doc.header.id), doc.contents.into_vec())?;

1246

3

    assert_eq!(document_42.id, 42);

1247

3

    let document_43 = Basic::new("43").insert_into(&43, db)?;

1248

3

    assert_eq!(document_43.header.id, 43);

1249

1250

    // Test that overwriting works

1251

3

    let overwritten = Basic::new("43")

1252

3

        .with_parent_id(document_42.id)

1253

3

        .overwrite_into(&doc.header.id, db)

1254

3

        .unwrap();

1255

3

    assert!(overwritten.header.revision.id > doc.header.revision.id);

1256

3

    let children = db

1257

3

        .view::<BasicByParentIdEager>()

1258

3

        .with_access_policy(AccessPolicy::NoUpdate)

1259

3

        .with_key(&Some(document_42.id))

1260

3

        .query()?;

1261

3

    assert_eq!(children[0].source.revision, overwritten.header.revision);

1262

1263

    // Verify that unique/eager views are updated when overwriting into a non-existant key

1264

3

    let insert_via_overwrite = Basic::new("1000")

1265

3

        .with_parent_id(document_43.header.id)

1266

3

        .overwrite_into(&1_000, db)

1267

3

        .unwrap();

1268

3

    let children = db

1269

3

        .view::<BasicByParentIdEager>()

1270

3

        .with_access_policy(AccessPolicy::NoUpdate)

1271

3

        .with_key(&Some(document_43.header.id))

1272

3

        .query()?;

1273

3

    assert_eq!(

1274

3

        children[0].source.revision,

1275

3

        insert_via_overwrite.header.revision

1276

3

);

1277

1278

3

    Ok(())

1279

3

1280

1281

5

pub async fn not_found_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1282

5

    assert!(db.collection::<Basic>().get(&1).await?.is_none());

1283

1284

5

    assert!(db.last_transaction_id().await?.is_none());

1285

1286

5

    Ok(())

1287

5

1288

1289

3

pub fn blocking_not_found_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

1290

3

    assert!(db.collection::<Basic>().get(&1)?.is_none());

1291

1292

3

    assert!(db.last_transaction_id()?.is_none());

1293

1294

3

    Ok(())

1295

3

1296

1297

5

pub async fn conflict_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1298

5

    let original_value = Basic::new("initial_value");

1299

5

    let collection = db.collection::<Basic>();

1300

5

    let header = collection.push(&original_value).await?;

1301

1302

5

    let mut doc = collection

1303

5

        .get(&header.id)

1304

5

        .await?

1305

5

        .expect("couldn't retrieve stored item");

1306

5

    let mut value = Basic::document_contents(&doc)?;

1307

5

    value.value = String::from("updated_value");

1308

5

    Basic::set_document_contents(&mut doc, value.clone())?;

1309

5

    db.update::<Basic, _>(&mut doc).await?;

1310

1311

    // To generate a conflict, let's try to do the same update again by

1312

    // reverting the header

1313

5

    doc.header = Header::try_from(header).unwrap();

1314

5

    let conflicting_header = db

1315

5

        .update::<Basic, _>(&mut doc)

1316

5

        .await

1317

5

        .expect_err("conflict should have generated an error")

1318

5

        .conflicting_document::<Basic>()

1319

5

        .expect("conflict not detected");

1320

5

    assert_eq!(conflicting_header.id, doc.header.id);

1321

1322

    // Let's force an update through overwrite. After this succeeds, the header

1323

    // is updated to the new revision.

1324

5

    db.collection::<Basic>().overwrite(&mut doc).await.unwrap();

1325

1326

    // Now, let's use the CollectionDocument API to modify the document through a refetch.

1327

5

    let mut doc = CollectionDocument::<Basic>::try_from(&doc)?;

1328

5

    doc.modify_async(db, |doc| {

1329

5

        doc.contents.value = String::from("modify worked");

1330

5

})

1331

5

    .await?;

1332

5

    assert_eq!(doc.contents.value, "modify worked");

1333

5

    let doc = Basic::get_async(&doc.header.id, db).await?.unwrap();

1334

5

    assert_eq!(doc.contents.value, "modify worked");

1335

1336

5

    Ok(())

1337

5

1338

1339

3

pub fn blocking_conflict_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

1340

3

    let original_value = Basic::new("initial_value");

1341

3

    let collection = db.collection::<Basic>();

1342

3

    let header = collection.push(&original_value)?;

1343

1344

3

    let mut doc = collection

1345

3

        .get(&header.id)?

1346

3

        .expect("couldn't retrieve stored item");

1347

3

    let mut value = Basic::document_contents(&doc)?;

1348

3

    value.value = String::from("updated_value");

1349

3

    Basic::set_document_contents(&mut doc, value)?;

1350

3

    db.update::<Basic, _>(&mut doc)?;

1351

1352

    // To generate a conflict, let's try to do the same update again by

1353

    // reverting the header

1354

3

    doc.header = Header::try_from(header).unwrap();

1355

3

    let conflicting_header = db

1356

3

        .update::<Basic, _>(&mut doc)

1357

3

        .expect_err("conflict should have generated an error")

1358

3

        .conflicting_document::<Basic>()

1359

3

        .expect("conflict not detected");

1360

3

    assert_eq!(conflicting_header.id, doc.header.id);

1361

1362

    // Let's force an update through overwrite. After this succeeds, the header

1363

    // is updated to the new revision.

1364

3

    db.collection::<Basic>().overwrite(&mut doc).unwrap();

1365

1366

    // Now, let's use the CollectionDocument API to modify the document through a refetch.

1367

3

    let mut doc = CollectionDocument::<Basic>::try_from(&doc)?;

1368

3

    doc.modify(db, |doc| {

1369

3

        doc.contents.value = String::from("modify worked");

1370

3

    })?;

1371

3

    assert_eq!(doc.contents.value, "modify worked");

1372

3

    let doc = Basic::get(&doc.header.id, db)?.unwrap();

1373

3

    assert_eq!(doc.contents.value, "modify worked");

1374

1375

3

    Ok(())

1376

3

1377

1378

5

pub async fn bad_update_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1379

5

    let mut doc = BorrowedDocument::with_contents::<Basic, _>(&1, &Basic::default())?;

1380

5

    match db.update::<Basic, _>(&mut doc).await {

1381

5

        Err(Error::DocumentNotFound(collection, id)) => {

1382

5

            assert_eq!(collection, Basic::collection_name());

1383

5

            assert_eq!(id.as_ref(), &DocumentId::from_u64(1));

1384

5

            Ok(())

1385

1386

        other => panic!("expected DocumentNotFound from update but got: {other:?}"),

1387

1388

5

1389

1390

3

pub fn blocking_bad_update_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

1391

3

    let mut doc = BorrowedDocument::with_contents::<Basic, _>(&1, &Basic::default())?;

1392

3

    match db.update::<Basic, _>(&mut doc) {

1393

3

        Err(Error::DocumentNotFound(collection, id)) => {

1394

3

            assert_eq!(collection, Basic::collection_name());

1395

3

            assert_eq!(id.as_ref(), &DocumentId::from_u64(1));

1396

3

            Ok(())

1397

1398

        other => panic!("expected DocumentNotFound from update but got: {other:?}"),

1399

1400

3

1401

1402

5

pub async fn no_update_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1403

5

    let original_value = Basic::new("initial_value");

1404

5

    let collection = db.collection::<Basic>();

1405

5

    let header = collection.push(&original_value).await?;

1406

1407

5

    let mut doc = collection

1408

5

        .get(&header.id)

1409

5

        .await?

1410

5

        .expect("couldn't retrieve stored item");

1411

5

    db.update::<Basic, _>(&mut doc).await?;

1412

1413

5

    assert_eq!(CollectionHeader::try_from(doc.header)?, header);

1414

1415

5

    Ok(())

1416

5

1417

1418

3

pub fn blocking_no_update_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

1419

3

    let original_value = Basic::new("initial_value");

1420

3

    let collection = db.collection::<Basic>();

1421

3

    let header = collection.push(&original_value)?;

1422

1423

3

    let mut doc = collection

1424

3

        .get(&header.id)?

1425

3

        .expect("couldn't retrieve stored item");

1426

3

    db.update::<Basic, _>(&mut doc)?;

1427

1428

3

    assert_eq!(CollectionHeader::try_from(doc.header)?, header);

1429

1430

3

    Ok(())

1431

3

1432

1433

5

pub async fn get_multiple_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1434

5

    let collection = db.collection::<Basic>();

1435

5

    let doc1_value = Basic::new("initial_value");

1436

5

    let doc1 = collection.push(&doc1_value).await?;

1437

1438

5

    let doc2_value = Basic::new("second_value");

1439

5

    let doc2 = collection.push(&doc2_value).await?;

1440

1441

5

    let both_docs = Basic::get_multiple_async([&doc1.id, &doc2.id], db).await?;

1442

5

    assert_eq!(both_docs.len(), 2);

1443

1444

5

    let out_of_order = Basic::get_multiple_async([&doc2.id, &doc1.id], db).await?;

1445

5

    assert_eq!(out_of_order.len(), 2);

1446

1447

    // The order of get_multiple isn't guaranteed, so these two checks are done

1448

    // with iterators instead of direct indexing

1449

5

    let doc1 = both_docs

1450

5

        .iter()

1451

5

        .find(|doc| doc.header.id == doc1.id)

1452

5

        .expect("Couldn't find doc1");

1453

5

    assert_eq!(doc1.contents.value, doc1_value.value);

1454

5

    let doc2 = both_docs

1455

5

        .iter()

1456

10

        .find(|doc| doc.header.id == doc2.id)

1457

5

        .expect("Couldn't find doc2");

1458

5

    assert_eq!(doc2.contents.value, doc2_value.value);

1459

1460

5

    Ok(())

1461

5

1462

1463

3

pub fn blocking_get_multiple_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

1464

3

    let collection = db.collection::<Basic>();

1465

3

    let doc1_value = Basic::new("initial_value");

1466

3

    let doc1 = collection.push(&doc1_value)?;

1467

1468

3

    let doc2_value = Basic::new("second_value");

1469

3

    let doc2 = collection.push(&doc2_value)?;

1470

1471

3

    let both_docs = Basic::get_multiple([&doc1.id, &doc2.id], db)?;

1472

3

    assert_eq!(both_docs.len(), 2);

1473

1474

3

    let out_of_order = Basic::get_multiple([&doc2.id, &doc1.id], db)?;

1475

3

    assert_eq!(out_of_order.len(), 2);

1476

1477

    // The order of get_multiple isn't guaranteed, so these two checks are done

1478

    // with iterators instead of direct indexing

1479

3

    let doc1 = both_docs

1480

3

        .iter()

1481

3

        .find(|doc| doc.header.id == doc1.id)

1482

3

        .expect("Couldn't find doc1");

1483

3

    assert_eq!(doc1.contents.value, doc1_value.value);

1484

3

    let doc2 = both_docs

1485

3

        .iter()

1486

6

        .find(|doc| doc.header.id == doc2.id)

1487

3

        .expect("Couldn't find doc2");

1488

3

    assert_eq!(doc2.contents.value, doc2_value.value);

1489

1490

3

    Ok(())

1491

3

1492

1493

5

pub async fn list_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1494

5

    let collection = db.collection::<Basic>();

1495

5

    let doc1_value = Basic::new("initial_value");

1496

5

    let doc1 = collection.push(&doc1_value).await?;

1497

1498

5

    let doc2_value = Basic::new("second_value");

1499

5

    let doc2 = collection.push(&doc2_value).await?;

1500

1501

5

    let all_docs = Basic::all_async(db).await?;

1502

5

    assert_eq!(all_docs.len(), 2);

1503

5

    assert_eq!(Basic::all_async(db).count().await?, 2);

1504

1505

5

    let both_docs = Basic::list_async(doc1.id..=doc2.id, db).await?;

1506

5

    assert_eq!(both_docs.len(), 2);

1507

5

    assert_eq!(Basic::list_async(doc1.id..=doc2.id, db).count().await?, 2);

1508

1509

5

    assert_eq!(both_docs[0].contents.value, doc1_value.value);

1510

5

    assert_eq!(both_docs[1].contents.value, doc2_value.value);

1511

1512

5

    let both_headers = Basic::list_async(doc1.id..=doc2.id, db).headers().await?;

1513

1514

5

    assert_eq!(both_headers.len(), 2);

1515

1516

5

    let one_doc = Basic::list_async(doc1.id..doc2.id, db).await?;

1517

5

    assert_eq!(one_doc.len(), 1);

1518

1519

5

    let limited = Basic::list_async(doc1.id..=doc2.id, db)

1520

5

        .limit(1)

1521

5

        .descending()

1522

5

        .await?;

1523

5

    assert_eq!(limited.len(), 1);

1524

5

    assert_eq!(limited[0].contents.value, doc2_value.value);

1525

1526

5

    Ok(())

1527

5

1528

1529

3

pub fn blocking_list_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

1530

3

    let collection = db.collection::<Basic>();

1531

3

    let doc1_value = Basic::new("initial_value");

1532

3

    let doc1 = collection.push(&doc1_value)?;

1533

1534

3

    let doc2_value = Basic::new("second_value");

1535

3

    let doc2 = collection.push(&doc2_value)?;

1536

1537

3

    let all_docs = Basic::all(db).query()?;

1538

3

    assert_eq!(all_docs.len(), 2);

1539

3

    assert_eq!(Basic::all(db).count()?, 2);

1540

1541

3

    let both_docs = Basic::list(doc1.id..=doc2.id, db).query()?;

1542

3

    assert_eq!(both_docs.len(), 2);

1543

3

    assert_eq!(Basic::list(doc1.id..=doc2.id, db).count()?, 2);

1544

1545

3

    assert_eq!(both_docs[0].contents.value, doc1_value.value);

1546

3

    assert_eq!(both_docs[1].contents.value, doc2_value.value);

1547

1548

3

    let both_headers = Basic::list(doc1.id..=doc2.id, db).headers()?;

1549

1550

3

    assert_eq!(both_headers.len(), 2);

1551

1552

3

    let one_doc = Basic::list(doc1.id..doc2.id, db).query()?;

1553

3

    assert_eq!(one_doc.len(), 1);

1554

1555

3

    let limited = Basic::list(doc1.id..=doc2.id, db)

1556

3

        .limit(1)

1557

3

        .descending()

1558

3

        .query()?;

1559

3

    assert_eq!(limited.len(), 1);

1560

3

    assert_eq!(limited[0].contents.value, doc2_value.value);

1561

1562

3

    Ok(())

1563

3

1564

1565

5

pub async fn list_transactions_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1566

5

    let collection = db.collection::<Basic>();

1567

5

1568

5

    // create LIST_TRANSACTIONS_MAX_RESULTS + 1 items, giving us just enough

1569

5

    // transactions to test the edge cases of `list_transactions`

1570

5

    futures::future::join_all(

1571

5

        (0..=(LIST_TRANSACTIONS_MAX_RESULTS))

1572

5005

            .map(|_| async { collection.push(&Basic::default()).await.unwrap() }),

1573

5

1574

4961

    .await;

1575

1576

    // Test defaults

1577

5

    let transactions = db.list_executed_transactions(None, None).await?;

1578

5

    assert_eq!(

1579

5

        u32::try_from(transactions.len()).unwrap(),

1580

5

        LIST_TRANSACTIONS_DEFAULT_RESULT_COUNT

1581

5

);

1582

1583

    // Test max results limit

1584

5

    let transactions = db

1585

5

        .list_executed_transactions(None, Some(LIST_TRANSACTIONS_MAX_RESULTS + 1))

1586

5

        .await?;

1587

5

    assert_eq!(

1588

5

        u32::try_from(transactions.len()).unwrap(),

1589

5

        LIST_TRANSACTIONS_MAX_RESULTS

1590

5

);

1591

1592

    // Test requesting 0 items

1593

5

    let transactions = db.list_executed_transactions(None, Some(0)).await?;

1594

5

    assert!(transactions.is_empty());

1595

1596

    // Test doing a loop fetching until we get no more results

1597

5

    let mut transactions = Vec::new();

1598

5

    let mut starting_id = None;

1599

    loop {

1600

60

        let chunk = db

1601

60

            .list_executed_transactions(starting_id, Some(100))

1602

60

            .await?;

1603

60

        if chunk.is_empty() {

1604

5

            break;

1605

55

1606

55

1607

55

        let max_id = chunk.last().map(|tx| tx.id).unwrap();

1608

55

        starting_id = Some(max_id + 1);

1609

55

        transactions.extend(chunk);

1610

1611

1612

5

    assert_eq!(

1613

5

        u32::try_from(transactions.len()).unwrap(),

1614

5

        LIST_TRANSACTIONS_MAX_RESULTS + 1

1615

5

);

1616

1617

5

    Ok(())

1618

5

1619

1620

3

pub fn blocking_list_transactions_tests<C: Connection + Clone + 'static>(

1621

3

    db: &C,

1622

3

) -> anyhow::Result<()> {

1623

3

    // create LIST_TRANSACTIONS_MAX_RESULTS + 1 items, giving us just enough

1624

3

    // transactions to test the edge cases of `list_transactions`

1625

3

    let mut threads = Vec::with_capacity(num_cpus::get());

1626

3

    let transaction_counter = Arc::new(AtomicU32::new(0));

1627

6

    for _ in 0..threads.capacity() {

1628

6

        let db = db.clone();

1629

6

        let transaction_counter = transaction_counter.clone();

1630

6

        threads.push(std::thread::spawn(move || {

1631

6

            let collection = db.collection::<Basic>();

1632

3009

            while transaction_counter.fetch_add(1, Ordering::SeqCst)

1633

3009

                <= LIST_TRANSACTIONS_MAX_RESULTS

1634

3003

1635

3003

                collection.push(&Basic::default()).unwrap();

1636

3003

1637

6

        }));

1638

6

1639

1640

9

    for thread in threads {

1641

6

        thread.join().unwrap();

1642

6

1643

1644

    // Test defaults

1645

3

    let transactions = db.list_executed_transactions(None, None)?;

1646

3

    assert_eq!(

1647

3

        u32::try_from(transactions.len()).unwrap(),

1648

3

        LIST_TRANSACTIONS_DEFAULT_RESULT_COUNT

1649

3

);

1650

1651

    // Test max results limit

1652

3

    let transactions =

1653

3

        db.list_executed_transactions(None, Some(LIST_TRANSACTIONS_MAX_RESULTS + 1))?;

1654

3

    assert_eq!(

1655

3

        u32::try_from(transactions.len()).unwrap(),

1656

3

        LIST_TRANSACTIONS_MAX_RESULTS

1657

3

);

1658

1659

    // Test requesting 0 items

1660

3

    let transactions = db.list_executed_transactions(None, Some(0))?;

1661

3

    assert!(transactions.is_empty());

1662

1663

    // Test doing a loop fetching until we get no more results

1664

3

    let mut transactions = Vec::new();

1665

3

    let mut starting_id = None;

1666

    loop {

1667

36

        let chunk = db.list_executed_transactions(starting_id, Some(100))?;

1668

36

        if chunk.is_empty() {

1669

3

            break;

1670

33

1671

33

1672

33

        let max_id = chunk.last().map(|tx| tx.id).unwrap();

1673

33

        starting_id = Some(max_id + 1);

1674

33

        transactions.extend(chunk);

1675

1676

1677

3

    assert_eq!(

1678

3

        u32::try_from(transactions.len()).unwrap(),

1679

3

        LIST_TRANSACTIONS_MAX_RESULTS + 1

1680

3

);

1681

1682

3

    Ok(())

1683

3

1684

1685

5

pub async fn transaction_tests<C: AsyncConnection + 'static>(db: &C) -> anyhow::Result<()> {

1686

5

    let mut tx = Transaction::new();

1687

5

    Basic::new("test").push_in_transaction(&mut tx)?;

1688

5

    let results = tx.apply_async(db).await?;

1689

5

    let OperationResult::DocumentUpdated { header, .. } = &results[0] else {

1690

        unreachable!("unexpected tx result")

1691

};

1692

5

    let id: u64 = header.id.deserialize()?;

1693

1694

    // Update the doc

1695

5

    let mut tx = Transaction::new();

1696

5

    let mut doc = Basic::get_async(&id, db).await?.expect("doc not found");

1697

5

    doc.contents.category = Some(String::from("cat"));

1698

5

    doc.update_in_transaction(&mut tx)?;

1699

5

    tx.apply_async(db).await?;

1700

5

    let doc = Basic::get_async(&id, db).await?.expect("doc not found");

1701

5

    assert_eq!(doc.contents.category.as_deref(), Some("cat"));

1702

1703

    // Overwrite the document.

1704

5

    let mut tx = Transaction::new();

1705

5

    Basic::new("test").overwrite_in_transaction(&id, &mut tx)?;

1706

5

    tx.apply_async(db).await?;

1707

5

    let doc = Basic::get_async(&id, db).await?.expect("doc not found");

1708

5

    assert_eq!(doc.contents.category, None);

1709

1710

    // Delete the document

1711

5

    let mut tx = Transaction::new();

1712

5

    doc.delete_in_transaction(&mut tx)?;

1713

5

    tx.apply_async(db).await?;

1714

1715

5

    Ok(())

1716

5

1717

1718

3

pub fn blocking_transaction_tests<C: Connection + 'static>(db: &C) -> anyhow::Result<()> {

1719

3

    let mut tx = Transaction::new();

1720

3

    Basic::new("test").push_in_transaction(&mut tx)?;

1721

3

    let results = tx.apply(db)?;

1722

3

    let OperationResult::DocumentUpdated { header, .. } = &results[0] else {

1723

        unreachable!("unexpected tx result")

1724

};

1725

3

    let id: u64 = header.id.deserialize()?;

1726

1727

    // Update the doc

1728

3

    let mut tx = Transaction::new();

1729

3

    let mut doc = Basic::get(&id, db)?.expect("doc not found");

1730

3

    doc.contents.category = Some(String::from("cat"));

1731

3

    doc.update_in_transaction(&mut tx)?;

1732

3

    tx.apply(db)?;

1733

3

    let doc = Basic::get(&id, db)?.expect("doc not found");

1734

3

    assert_eq!(doc.contents.category.as_deref(), Some("cat"));

1735

1736

    // Overwrite the document.

1737

3

    let mut tx = Transaction::new();

1738

3

    Basic::new("test").overwrite_in_transaction(&id, &mut tx)?;

1739

3

    tx.apply(db)?;

1740

3

    let doc = Basic::get(&id, db)?.expect("doc not found");

1741

3

    assert_eq!(doc.contents.category, None);

1742

1743

    // Delete the document

1744

3

    let mut tx = Transaction::new();

1745

3

    doc.delete_in_transaction(&mut tx)?;

1746

3

    tx.apply(db)?;

1747

1748

3

    Ok(())

1749

3

1750

1751

5

pub async fn transaction_check_tests<C: AsyncConnection + 'static>(db: &C) -> anyhow::Result<()> {

1752

5

    let mut doc = Basic::new("test").push_into_async(db).await?;

1753

5

    let mut refreshable = doc.clone();

1754

5

    let initial_header = doc.header;

1755

5

    doc.contents.value = String::from("updated");

1756

5

    doc.update_async(db).await?;

1757

1758

5

    refreshable.refresh_async(db).await?;

1759

5

    assert_eq!(refreshable.contents.value, "updated");

1760

1761

    // Positive flow, check id, as well as id + header.

1762

5

    let mut tx = Transaction::new();

1763

5

    tx.push(Operation::check_document_exists::<Basic>(&doc.header.id)?);

1764

5

    tx.push(Operation::check_document_is_current::<Basic, _>(&doc)?);

1765

5

    tx.push(Operation::insert_serialized::<Basic>(

1766

5

        None,

1767

5

        &Basic::new("new doc"),

1768

5

    )?);

1769

5

    tx.apply_async(db).await?;

1770

1771

    // Error flows. Ensure the first violation is the error returned.

1772

5

    let mut tx = Transaction::new();

1773

5

    tx.push(Operation::check_document_is_current::<Basic, _>(

1774

5

        &initial_header,

1775

5

    )?);

1776

5

    tx.push(Operation::check_document_exists::<Basic>(&42)?);

1777

5

    let result = tx.apply_async(db).await.unwrap_err();

1778

5

    assert!(matches!(result, Error::DocumentConflict(_, _)));

1779

1780

5

    let mut tx = Transaction::new();

1781

5

    tx.push(Operation::check_document_exists::<Basic>(&42)?);

1782

5

    tx.push(Operation::check_document_is_current::<Basic, _>(

1783

5

        &initial_header,

1784

5

    )?);

1785

5

    let result = tx.apply_async(db).await.unwrap_err();

1786

5

    assert!(matches!(result, Error::DocumentNotFound(_, _)));

1787

1788

5

    Ok(())

1789

5

1790

1791

3

pub fn blocking_transaction_check_tests<C: Connection + 'static>(db: &C) -> anyhow::Result<()> {

1792

3

    let mut doc = Basic::new("test").push_into(db)?;

1793

3

    let mut refreshable = doc.clone();

1794

3

    let initial_header = doc.header;

1795

3

    doc.contents.value = String::from("updated");

1796

3

    doc.update(db)?;

1797

1798

3

    refreshable.refresh(db)?;

1799

3

    assert_eq!(refreshable.contents.value, "updated");

1800

1801

    // Positive flow, check id, as well as id + header.

1802

3

    let mut tx = Transaction::new();

1803

3

    tx.push(Operation::check_document_exists::<Basic>(&doc.header.id)?);

1804

3

    tx.push(Operation::check_document_is_current::<Basic, _>(&doc)?);

1805

3

    tx.push(Operation::insert_serialized::<Basic>(

1806

3

        None,

1807

3

        &Basic::new("new doc"),

1808

3

    )?);

1809

3

    tx.apply(db)?;

1810

1811

    // Error flows. Ensure the first violation is the error returned.

1812

3

    let mut tx = Transaction::new();

1813

3

    tx.push(Operation::check_document_is_current::<Basic, _>(

1814

3

        &initial_header,

1815

3

    )?);

1816

3

    tx.push(Operation::check_document_exists::<Basic>(&42)?);

1817

3

    let result = tx.apply(db).unwrap_err();

1818

3

    assert!(matches!(result, Error::DocumentConflict(_, _)));

1819

1820

3

    let mut tx = Transaction::new();

1821

3

    tx.push(Operation::check_document_exists::<Basic>(&42)?);

1822

3

    tx.push(Operation::check_document_is_current::<Basic, _>(

1823

3

        &initial_header,

1824

3

    )?);

1825

3

    let result = tx.apply(db).unwrap_err();

1826

3

    assert!(matches!(result, Error::DocumentNotFound(_, _)));

1827

1828

3

    Ok(())

1829

3

1830

1831

5

pub async fn view_query_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

1832

5

    let collection = db.collection::<Basic>();

1833

5

    let a = collection.push(&Basic::new("A")).await?;

1834

5

    let b = collection.push(&Basic::new("B")).await?;

1835

5

    let a_child = collection

1836

5

        .push(

1837

5

            &Basic::new("A.1")

1838

5

                .with_parent_id(a.id)

1839

5

                .with_category("Alpha"),

1840

5

1841

5

        .await?;

1842

5

    collection

1843

5

        .push(&Basic::new("B.1").with_parent_id(b.id).with_category("Beta"))

1844

5

        .await?;

1845

5

    collection

1846

5

        .push(&Basic::new("B.2").with_parent_id(b.id).with_category("beta"))

1847

5

        .await?;

1848

1849

5

    let a_children = db

1850

5

        .view::<BasicByParentId>()

1851

5

        .with_key(&Some(a.id))

1852

5

        .query()

1853

5

        .await?;

1854

5

    assert_eq!(a_children.len(), 1);

1855

1856

5

    let a_children = db

1857

5

        .view::<BasicByParentId>()

1858

5

        .with_key(&Some(a.id))

1859

5

        .query_with_collection_docs()

1860

10

        .await?;

1861

5

    assert_eq!(a_children.len(), 1);

1862

5

    assert_eq!(a_children.get(0).unwrap().document.header, a_child);

1863

1864

5

    let b_children = db

1865

5

        .view::<BasicByParentId>()

1866

5

        .with_key(&Some(b.id))

1867

5

        .query()

1868

5

        .await?;

1869

5

    assert_eq!(b_children.len(), 2);

1870

1871

5

    let a_and_b_children = db

1872

5

        .view::<BasicByParentId>()

1873

5

        .with_keys([&Some(a.id), &Some(b.id)])

1874

5

        .query()

1875

5

        .await?;

1876

5

    assert_eq!(a_and_b_children.len(), 3);

1877

1878

    // Test out of order keys

1879

5

    let a_and_b_children = db

1880

5

        .view::<BasicByParentId>()

1881

5

        .with_keys([&Some(b.id), &Some(a.id)])

1882

5

        .query()

1883

5

        .await?;

1884

5

    assert_eq!(a_and_b_children.len(), 3);

1885

1886

5

    let has_parent = db

1887

5

        .view::<BasicByParentId>()

1888

5

        .with_key_range(Some(0)..=Some(u64::MAX))

1889

5

        .query()

1890

5

        .await?;

1891

5

    assert_eq!(has_parent.len(), 3);

1892

    // Verify the result is sorted ascending

1893

5

    assert!(has_parent

1894

5

        .windows(2)

1895

10

        .all(|window| window[0].key <= window[1].key));

1896

1897

    // Test limiting and descending order

1898

5

    let last_with_parent = db

1899

5

        .view::<BasicByParentId>()

1900

5

        .with_key_range(Some(0)..=Some(u64::MAX))

1901

5

        .descending()

1902

5

        .limit(1)

1903

5

        .query()

1904

5

        .await?;

1905

10

    assert_eq!(last_with_parent.iter().map(|m| m.key).unique().count(), 1);

1906

5

    assert_eq!(last_with_parent[0].key, has_parent[2].key);

1907

1908

5

    let items_with_categories = db.view::<BasicByCategory>().query().await?;

1909

5

    assert_eq!(items_with_categories.len(), 3);

1910

1911

    // Test deleting

1912

5

    let deleted_count = db

1913

5

        .view::<BasicByParentId>()

1914

5

        .with_key(&Some(b.id))

1915

5

        .delete_docs()

1916

5

        .await?;

1917

5

    assert_eq!(b_children.len() as u64, deleted_count);

1918

    assert_eq!(

1919

5

        db.view::<BasicByParentId>()

1920

5

            .with_key(&Some(b.id))

1921

5

            .query()

1922

5

            .await?

1923

5

            .len(),

1924

1925

);

1926

1927

5

    Ok(())

1928

5

1929

1930

3

pub fn blocking_view_query_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

1931

3

    let collection = db.collection::<Basic>();

1932

3

    let a = collection.push(&Basic::new("A"))?;

1933

3

    let b = collection.push(&Basic::new("B"))?;

1934

3

    let a_child = collection.push(

1935

3

        &Basic::new("A.1")

1936

3

            .with_parent_id(a.id)

1937

3

            .with_category("Alpha"),

1938

3

)?;

1939

3

    collection.push(&Basic::new("B.1").with_parent_id(b.id).with_category("Beta"))?;

1940

3

    collection.push(&Basic::new("B.2").with_parent_id(b.id).with_category("beta"))?;

1941

1942

3

    let a_children = db.view::<BasicByParentId>().with_key(&Some(a.id)).query()?;

1943

3

    assert_eq!(a_children.len(), 1);

1944

1945

3

    let a_children = db

1946

3

        .view::<BasicByParentId>()

1947

3

        .with_key(&Some(a.id))

1948

3

        .query_with_collection_docs()?;

1949

3

    assert_eq!(a_children.len(), 1);

1950

3

    assert_eq!(a_children.get(0).unwrap().document.header, a_child);

1951

1952

3

    let b_children = db.view::<BasicByParentId>().with_key(&Some(b.id)).query()?;

1953

3

    assert_eq!(b_children.len(), 2);

1954

1955

3

    let a_and_b_children = db

1956

3

        .view::<BasicByParentId>()

1957

3

        .with_keys(&[Some(a.id), Some(b.id)])

1958

3

        .query()?;

1959

3

    assert_eq!(a_and_b_children.len(), 3);

1960

1961

    // Test out of order keys

1962

3

    let a_and_b_children = db

1963

3

        .view::<BasicByParentId>()

1964

3

        .with_keys(&[Some(b.id), Some(a.id)])

1965

3

        .query()?;

1966

3

    assert_eq!(a_and_b_children.len(), 3);

1967

1968

3

    let has_parent = db

1969

3

        .view::<BasicByParentId>()

1970

3

        .with_key_range(Some(0)..=Some(u64::MAX))

1971

3

        .query()?;

1972

3

    assert_eq!(has_parent.len(), 3);

1973

    // Verify the result is sorted ascending

1974

3

    assert!(has_parent

1975

3

        .windows(2)

1976

6

        .all(|window| window[0].key <= window[1].key));

1977

1978

    // Test limiting and descending order

1979

3

    let last_with_parent = db

1980

3

        .view::<BasicByParentId>()

1981

3

        .with_key_range(Some(0)..=Some(u64::MAX))

1982

3

        .descending()

1983

3

        .limit(1)

1984

3

        .query()?;

1985

6

    assert_eq!(last_with_parent.iter().map(|m| m.key).unique().count(), 1);

1986

3

    assert_eq!(last_with_parent[0].key, has_parent[2].key);

1987

1988

3

    let items_with_categories = db.view::<BasicByCategory>().query()?;

1989

3

    assert_eq!(items_with_categories.len(), 3);

1990

1991

    // Test deleting

1992

3

    let deleted_count = db

1993

3

        .view::<BasicByParentId>()

1994

3

        .with_key(&Some(b.id))

1995

3

        .delete_docs()?;

1996

3

    assert_eq!(b_children.len() as u64, deleted_count);

1997

3

    assert_eq!(

1998

3

        db.view::<BasicByParentId>()

1999

3

            .with_key(&Some(b.id))

2000

3

            .query()?

2001

3

            .len(),

2002

2003

);

2004

2005

3

    Ok(())

2006

3

2007

2008

5

pub async fn unassociated_collection_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

2009

5

    let result = db

2010

5

        .collection::<UnassociatedCollection>()

2011

5

        .push(&UnassociatedCollection)

2012

5

        .await;

2013

5

    match result {

2014

5

        Err(Error::CollectionNotFound) => {}

2015

        other => unreachable!("unexpected result: {:?}", other),

2016

2017

2018

5

    Ok(())

2019

5

2020

2021

3

pub fn blocking_unassociated_collection_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

2022

3

    let result = db

2023

3

        .collection::<UnassociatedCollection>()

2024

3

        .push(&UnassociatedCollection);

2025

3

    match result {

2026

3

        Err(Error::CollectionNotFound) => {}

2027

        other => unreachable!("unexpected result: {:?}", other),

2028

2029

2030

3

    Ok(())

2031

3

2032

2033

5

pub async fn unimplemented_reduce<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

2034

5

    assert!(matches!(

2035

5

        db.view::<UniqueValue>().reduce().await,

2036

        Err(Error::ReduceUnimplemented)

2037

));

2038

5

    Ok(())

2039

5

2040

2041

3

pub fn blocking_unimplemented_reduce<C: Connection>(db: &C) -> anyhow::Result<()> {

2042

3

    assert!(matches!(

2043

3

        db.view::<UniqueValue>().reduce(),

2044

        Err(Error::ReduceUnimplemented)

2045

));

2046

3

    Ok(())

2047

3

2048

2049

#[allow(clippy::too_many_lines)] // The non-async version is less than the limit :)

2050

5

pub async fn view_update_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

2051

5

    let collection = db.collection::<Basic>();

2052

5

    let a = collection.push(&Basic::new("A")).await?;

2053

2054

5

    let a_children = db

2055

5

        .view::<BasicByParentId>()

2056

5

        .with_key(&Some(a.id))

2057

5

        .query()

2058

5

        .await?;

2059

5

    assert_eq!(a_children.len(), 0);

2060

    // The reduce function of `BasicByParentId` acts as a "count" of records.

2061

    assert_eq!(

2062

5

        db.view::<BasicByParentId>()

2063

5

            .with_key(&Some(a.id))

2064

5

            .reduce()

2065

5

            .await?,

2066

2067

);

2068

2069

    // Verify the eager view is available without any updates

2070

5

    let a_children = db

2071

5

        .view::<BasicByParentId>()

2072

5

        .with_key(&Some(a.id))

2073

5

        .with_access_policy(AccessPolicy::NoUpdate)

2074

5

        .query()

2075

5

        .await?;

2076

5

    assert_eq!(a_children.len(), 0);

2077

    assert_eq!(

2078

5

        db.view::<BasicByParentId>()

2079

5

            .with_key(&Some(a.id))

2080

5

            .with_access_policy(AccessPolicy::NoUpdate)

2081

5

            .reduce()

2082

5

            .await?,

2083

2084

);

2085

2086

    // Test inserting a new record and the view being made available

2087

5

    let a_child = collection

2088

5

        .push(

2089

5

            &Basic::new("A.1")

2090

5

                .with_parent_id(a.id)

2091

5

                .with_category("Alpha"),

2092

5

2093

5

        .await?;

2094

2095

5

    let a_children = db

2096

5

        .view::<BasicByParentId>()

2097

5

        .with_key(&Some(a.id))

2098

5

        .query()

2099

5

        .await?;

2100

5

    assert_eq!(a_children.len(), 1);

2101

    assert_eq!(

2102

5

        db.view::<BasicByParentId>()

2103

5

            .with_key(&Some(a.id))

2104

5

            .reduce()

2105

5

            .await?,

2106

2107

);

2108

2109

    // Verify reduce_grouped matches our expectations.

2110

    assert_eq!(

2111

5

        db.view::<BasicByParentId>().reduce_grouped().await?,

2112

5

        vec![MappedValue::new(None, 1,), MappedValue::new(Some(a.id), 1,),]

2113

);

2114

2115

    // Test updating the record and the view being updated appropriately

2116

5

    let b = collection.push(&Basic::new("B")).await?;

2117

5

    let mut doc = db.collection::<Basic>().get(&a_child.id).await?.unwrap();

2118

5

    let mut basic = Basic::document_contents(&doc)?;

2119

5

    basic.parent_id = Some(b.id);

2120

5

    Basic::set_document_contents(&mut doc, basic)?;

2121

5

    db.update::<Basic, _>(&mut doc).await?;

2122

2123

5

    let b_children = db

2124

5

        .view::<BasicByParentId>()

2125

5

        .with_key(&Some(b.id))

2126

5

        .query()

2127

5

        .await?;

2128

5

    assert_eq!(b_children.len(), 1);

2129

5

    assert_eq!(

2130

5

        b_children[0].source,

2131

5

        CollectionHeader::try_from(&doc.header)?

2132

);

2133

    assert_eq!(

2134

5

        db.view::<BasicByParentId>()

2135

5

            .with_key(&Some(a.id))

2136

5

            .reduce()

2137

5

            .await?,

2138

2139

);

2140

5

    assert_eq!(db.view::<BasicByParentId>().reduce().await?, 3);

2141

2142

    // Update the record, but don't change its mapping. Ensure the source's

2143

    // header is updated.

2144

5

    let mut basic = Basic::document_contents(&doc)?;

2145

5

    basic.value = String::from("new value");

2146

5

    Basic::set_document_contents(&mut doc, basic)?;

2147

5

    db.update::<Basic, _>(&mut doc).await?;

2148

5

    let b_children = db

2149

5

        .view::<BasicByParentId>()

2150

5

        .with_key(&Some(b.id))

2151

5

        .query()

2152

5

        .await?;

2153

5

    assert_eq!(b_children.len(), 1);

2154

5

    assert_eq!(

2155

5

        b_children[0].source,

2156

5

        CollectionHeader::try_from(&doc.header)?

2157

);

2158

2159

    // Test deleting a record and ensuring it goes away

2160

5

    db.collection::<Basic>().delete(&doc).await?;

2161

2162

5

    let all_entries = db.view::<BasicByParentId>().query().await?;

2163

5

    assert_eq!(all_entries.len(), 2);

2164

2165

    // Verify reduce_grouped matches our expectations.

2166

    assert_eq!(

2167

5

        db.view::<BasicByParentId>().reduce_grouped().await?,

2168

5

        vec![MappedValue::new(None, 2,),]

2169

);

2170

2171

    // Remove the final document, which has a parent id of None. We'll add a new

2172

    // document with None to verify that the mapper handles the edge case of a

2173

    // delete/insert in the same mapping operation.

2174

5

    db.view::<BasicByParentId>().delete_docs().await?;

2175

5

    collection.push(&Basic::new("B")).await?;

2176

2177

5

    let all_entries = db.view::<BasicByParentId>().query().await?;

2178

5

    assert_eq!(all_entries.len(), 1);

2179

2180

5

    Ok(())

2181

5

2182

2183

3

pub fn blocking_view_update_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

2184

3

    let collection = db.collection::<Basic>();

2185

3

    let a = collection.push(&Basic::new("A"))?;

2186

2187

3

    let a_children = db.view::<BasicByParentId>().with_key(&Some(a.id)).query()?;

2188

3

    assert_eq!(a_children.len(), 0);

2189

    // The reduce function of `BasicByParentId` acts as a "count" of records.

2190

3

    assert_eq!(

2191

3

        db.view::<BasicByParentId>()

2192

3

            .with_key(&Some(a.id))

2193

3

            .reduce()?,

2194

2195

);

2196

2197

    // Verify the eager view is available without any updates

2198

3

    let a_children = db

2199

3

        .view::<BasicByParentId>()

2200

3

        .with_key(&Some(a.id))

2201

3

        .with_access_policy(AccessPolicy::NoUpdate)

2202

3

        .query()?;

2203

3

    assert_eq!(a_children.len(), 0);

2204

3

    assert_eq!(

2205

3

        db.view::<BasicByParentId>()

2206

3

            .with_key(&Some(a.id))

2207

3

            .with_access_policy(AccessPolicy::NoUpdate)

2208

3

            .reduce()?,

2209

2210

);

2211

2212

    // Test inserting a new record and the view being made available

2213

3

    let a_child = collection.push(

2214

3

        &Basic::new("A.1")

2215

3

            .with_parent_id(a.id)

2216

3

            .with_category("Alpha"),

2217

3

)?;

2218

2219

3

    let a_children = db.view::<BasicByParentId>().with_key(&Some(a.id)).query()?;

2220

3

    assert_eq!(a_children.len(), 1);

2221

3

    assert_eq!(

2222

3

        db.view::<BasicByParentId>()

2223

3

            .with_key(&Some(a.id))

2224

3

            .reduce()?,

2225

2226

);

2227

2228

    // Verify reduce_grouped matches our expectations.

2229

3

    assert_eq!(

2230

3

        db.view::<BasicByParentId>().reduce_grouped()?,

2231

3

        vec![MappedValue::new(None, 1,), MappedValue::new(Some(a.id), 1,),]

2232

);

2233

2234

    // Test updating the record and the view being updated appropriately

2235

3

    let b = collection.push(&Basic::new("B"))?;

2236

3

    let mut doc = db.collection::<Basic>().get(&a_child.id)?.unwrap();

2237

3

    let mut basic = Basic::document_contents(&doc)?;

2238

3

    basic.parent_id = Some(b.id);

2239

3

    Basic::set_document_contents(&mut doc, basic)?;

2240

3

    db.update::<Basic, _>(&mut doc)?;

2241

2242

3

    let b_children = db.view::<BasicByParentId>().with_key(&Some(b.id)).query()?;

2243

3

    assert_eq!(b_children.len(), 1);

2244

3

    assert_eq!(

2245

3

        b_children[0].source,

2246

3

        CollectionHeader::try_from(&doc.header)?

2247

);

2248

3

    assert_eq!(

2249

3

        db.view::<BasicByParentId>()

2250

3

            .with_key(&Some(a.id))

2251

3

            .reduce()?,

2252

2253

);

2254

3

    assert_eq!(db.view::<BasicByParentId>().reduce()?, 3);

2255

2256

    // Update the record, but don't change its mapping. Ensure the source's

2257

    // header is updated.

2258

3

    let mut basic = Basic::document_contents(&doc)?;

2259

3

    basic.value = String::from("new value");

2260

3

    Basic::set_document_contents(&mut doc, basic)?;

2261

3

    db.update::<Basic, _>(&mut doc)?;

2262

3

    let b_children = db.view::<BasicByParentId>().with_key(&Some(b.id)).query()?;

2263

3

    assert_eq!(b_children.len(), 1);

2264

3

    assert_eq!(

2265

3

        b_children[0].source,

2266

3

        CollectionHeader::try_from(&doc.header)?

2267

);

2268

2269

    // Test deleting a record and ensuring it goes away

2270

3

    db.collection::<Basic>().delete(&doc)?;

2271

2272

3

    let all_entries = db.view::<BasicByParentId>().query()?;

2273

3

    assert_eq!(all_entries.len(), 2);

2274

2275

    // Verify reduce_grouped matches our expectations.

2276

3

    assert_eq!(

2277

3

        db.view::<BasicByParentId>().reduce_grouped()?,

2278

3

        vec![MappedValue::new(None, 2,),]

2279

);

2280

2281

    // Remove the final document, which has a parent id of None. We'll add a new

2282

    // document with None to verify that the mapper handles the edge case of a

2283

    // delete/insert in the same mapping operation.

2284

3

    db.view::<BasicByParentId>().delete_docs()?;

2285

3

    collection.push(&Basic::new("B"))?;

2286

2287

3

    let all_entries = db.view::<BasicByParentId>().query()?;

2288

3

    assert_eq!(all_entries.len(), 1);

2289

2290

3

    Ok(())

2291

3

2292

2293

5

pub async fn view_multi_emit_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

2294

5

    let mut a = Basic::new("A")

2295

5

        .with_tag("red")

2296

5

        .with_tag("green")

2297

5

        .push_into_async(db)

2298

5

        .await?;

2299

5

    let mut b = Basic::new("B")

2300

5

        .with_tag("blue")

2301

5

        .with_tag("green")

2302

5

        .push_into_async(db)

2303

5

        .await?;

2304

2305

5

    assert_eq!(db.view::<BasicByTag>().query().await?.len(), 4);

2306

2307

    assert_eq!(

2308

5

        db.view::<BasicByTag>()

2309

5

            .with_key("green")

2310

5

            .query()

2311

5

            .await?

2312

5

            .len(),

2313

2314

);

2315

2316

    assert_eq!(

2317

5

        db.view::<BasicByTag>().with_key("red").query().await?.len(),

2318

2319

);

2320

2321

    assert_eq!(

2322

5

        db.view::<BasicByTag>()

2323

5

            .with_key("blue")

2324

5

            .query()

2325

5

            .await?

2326

5

            .len(),

2327

2328

);

2329

2330

    // Change tags

2331

5

    a.contents.tags = vec![String::from("red"), String::from("blue")];

2332

5

    a.update_async(db).await?;

2333

2334

    assert_eq!(

2335

5

        db.view::<BasicByTag>()

2336

5

            .with_key("green")

2337

5

            .query()

2338

5

            .await?

2339

5

            .len(),

2340

2341

);

2342

2343

    assert_eq!(

2344

5

        db.view::<BasicByTag>().with_key("red").query().await?.len(),

2345

2346

);

2347

2348

    assert_eq!(

2349

5

        db.view::<BasicByTag>()

2350

5

            .with_key("blue")

2351

5

            .query()

2352

5

            .await?

2353

5

            .len(),

2354

2355

);

2356

5

    b.contents.tags.clear();

2357

5

    b.update_async(db).await?;

2358

2359

    assert_eq!(

2360

5

        db.view::<BasicByTag>()

2361

5

            .with_key("green")

2362

5

            .query()

2363

5

            .await?

2364

5

            .len(),

2365

2366

);

2367

2368

    assert_eq!(

2369

5

        db.view::<BasicByTag>().with_key("red").query().await?.len(),

2370

2371

);

2372

2373

    assert_eq!(

2374

5

        db.view::<BasicByTag>()

2375

5

            .with_key("blue")

2376

5

            .query()

2377

5

            .await?

2378

5

            .len(),

2379

2380

);

2381

2382

5

    Ok(())

2383

5

2384

2385

3

pub fn blocking_view_multi_emit_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

2386

3

    let mut a = Basic::new("A")

2387

3

        .with_tag("red")

2388

3

        .with_tag("green")

2389

3

        .push_into(db)?;

2390

3

    let mut b = Basic::new("B")

2391

3

        .with_tag("blue")

2392

3

        .with_tag("green")

2393

3

        .push_into(db)?;

2394

2395

3

    assert_eq!(db.view::<BasicByTag>().query()?.len(), 4);

2396

2397

3

    assert_eq!(db.view::<BasicByTag>().with_key("green").query()?.len(), 2);

2398

2399

3

    assert_eq!(db.view::<BasicByTag>().with_key("red").query()?.len(), 1);

2400

2401

3

    assert_eq!(db.view::<BasicByTag>().with_key("blue").query()?.len(), 1);

2402

2403

    // Change tags

2404

3

    a.contents.tags = vec![String::from("red"), String::from("blue")];

2405

3

    a.update(db)?;

2406

2407

3

    assert_eq!(db.view::<BasicByTag>().with_key("green").query()?.len(), 1);

2408

2409

3

    assert_eq!(db.view::<BasicByTag>().with_key("red").query()?.len(), 1);

2410

2411

3

    assert_eq!(db.view::<BasicByTag>().with_key("blue").query()?.len(), 2);

2412

3

    b.contents.tags.clear();

2413

3

    b.update(db)?;

2414

2415

3

    assert_eq!(db.view::<BasicByTag>().with_key("green").query()?.len(), 0);

2416

2417

3

    assert_eq!(db.view::<BasicByTag>().with_key("red").query()?.len(), 1);

2418

2419

3

    assert_eq!(db.view::<BasicByTag>().with_key("blue").query()?.len(), 1);

2420

2421

3

    Ok(())

2422

3

2423

2424

5

pub async fn view_access_policy_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

2425

5

    let collection = db.collection::<Basic>();

2426

2427

    // Query the view to get it into a consistent, mapped state. If we don't

2428

    // query it, the integrity checker can end up spawning a mapping job. This

2429

    // job would run in the background and can include the next documents being

2430

    // inserted.

2431

5

    let all_entries = db.view::<BasicByParentId>().query().await?;

2432

5

    assert_eq!(all_entries.len(), 0);

2433

2434

5

    let a = collection.push(&Basic::new("A")).await?;

2435

2436

    // Test inserting a record that should match the view, but ask for it to be

2437

    // NoUpdate. Verify we get no matches.

2438

5

    collection

2439

5

        .push(

2440

5

            &Basic::new("A.1")

2441

5

                .with_parent_id(a.id)

2442

5

                .with_category("Alpha"),

2443

5

2444

5

        .await?;

2445

2446

5

    let a_children = db

2447

5

        .view::<BasicByParentId>()

2448

5

        .with_key(&Some(a.id))

2449

5

        .with_access_policy(AccessPolicy::NoUpdate)

2450

5

        .query()

2451

5

        .await?;

2452

5

    assert_eq!(a_children.len(), 0);

2453

2454

5

    tokio::time::sleep(Duration::from_millis(20)).await;

2455

2456

    // Verify the view still have no value, but this time ask for it to be

2457

    // updated after returning

2458

5

    let a_children = db

2459

5

        .view::<BasicByParentId>()

2460

5

        .with_key(&Some(a.id))

2461

5

        .with_access_policy(AccessPolicy::UpdateAfter)

2462

5

        .query()

2463

5

        .await?;

2464

5

    assert_eq!(a_children.len(), 0);

2465

2466

    // Waiting on background jobs can be unreliable in a CI environment

2467

5

    for _ in 0..10_u8 {

2468

5

        tokio::time::sleep(Duration::from_millis(20)).await;

2469

2470

        // Now, the view should contain the entry.

2471

5

        let a_children = db

2472

5

            .view::<BasicByParentId>()

2473

5

            .with_key(&Some(a.id))

2474

5

            .with_access_policy(AccessPolicy::NoUpdate)

2475

5

            .query()

2476

5

            .await?;

2477

5

        if a_children.len() == 1 {

2478

5

            return Ok(());

2479

2480

2481

    panic!("view never updated")

2482

5

2483

2484

3

pub fn blocking_view_access_policy_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

2485

    // Query the view to get it into a consistent, mapped state. If we don't

2486

    // query it, the integrity checker can end up spawning a mapping job. This

2487

    // job would run in the background and can include the next documents being

2488

    // inserted.

2489

3

    let all_entries = db.view::<BasicByParentId>().query()?;

2490

3

    assert_eq!(all_entries.len(), 0);

2491

2492

3

    let collection = db.collection::<Basic>();

2493

3

    let a = collection.push(&Basic::new("A"))?;

2494

2495

    // Test inserting a record that should match the view, but ask for it to be

2496

    // NoUpdate. Verify we get no matches.

2497

3

    collection.push(

2498

3

        &Basic::new("A.1")

2499

3

            .with_parent_id(a.id)

2500

3

            .with_category("Alpha"),

2501

3

)?;

2502

2503

3

    let a_children = db

2504

3

        .view::<BasicByParentId>()

2505

3

        .with_key(&Some(a.id))

2506

3

        .with_access_policy(AccessPolicy::NoUpdate)

2507

3

        .query()?;

2508

3

    assert_eq!(a_children.len(), 0);

2509

2510

3

    std::thread::sleep(Duration::from_millis(20));

2511

2512

    // Verify the view still have no value, but this time ask for it to be

2513

    // updated after returning

2514

3

    let a_children = db

2515

3

        .view::<BasicByParentId>()

2516

3

        .with_key(&Some(a.id))

2517

3

        .with_access_policy(AccessPolicy::UpdateAfter)

2518

3

        .query()?;

2519

3

    assert_eq!(a_children.len(), 0);

2520

2521

    // Waiting on background jobs can be unreliable in a CI environment

2522

3

    for _ in 0..10_u8 {

2523

3

        std::thread::sleep(Duration::from_millis(20));

2524

2525

        // Now, the view should contain the entry.

2526

3

        let a_children = db

2527

3

            .view::<BasicByParentId>()

2528

3

            .with_key(&Some(a.id))

2529

3

            .with_access_policy(AccessPolicy::NoUpdate)

2530

3

            .query()?;

2531

3

        if a_children.len() == 1 {

2532

3

            return Ok(());

2533

2534

2535

    panic!("view never updated")

2536

3

2537

2538

5

pub async fn unique_view_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

2539

5

    let first_doc = db.collection::<Unique>().push(&Unique::new("1")).await?;

2540

2541

    if let Err(Error::UniqueKeyViolation {

2542

5

        view,

2543

5

        existing_document,

2544

5

        conflicting_document,

2545

5

    }) = db.collection::<Unique>().push(&Unique::new("1")).await

2546

2547

5

        assert_eq!(view, UniqueValue.view_name());

2548

5

        assert_eq!(first_doc.id, existing_document.id.deserialize()?);

2549

        // We can't predict the conflicting document id since it's generated

2550

        // inside of the transaction, but we can assert that it's different than

2551

        // the document that was previously stored.

2552

5

        assert_ne!(conflicting_document, existing_document);

2553

    } else {

2554

        unreachable!("unique key violation not triggered");

2555

2556

2557

5

    let second_doc = db.collection::<Unique>().push(&Unique::new("2")).await?;

2558

5

    let mut second_doc = db

2559

5

        .collection::<Unique>()

2560

5

        .get(&second_doc.id)

2561

5

        .await?

2562

5

        .unwrap();

2563

5

    let mut contents = Unique::document_contents(&second_doc)?;

2564

5

    contents.value = String::from("1");

2565

5

    Unique::set_document_contents(&mut second_doc, contents)?;

2566

    if let Err(Error::UniqueKeyViolation {

2567

5

        view,

2568

5

        existing_document,

2569

5

        conflicting_document,

2570

5

    }) = db.update::<Unique, _>(&mut second_doc).await

2571

2572

5

        assert_eq!(view, UniqueValue.view_name());

2573

5

        assert_eq!(first_doc.id, existing_document.id.deserialize()?);

2574

5

        assert_eq!(conflicting_document.id, second_doc.header.id);

2575

    } else {

2576

        unreachable!("unique key violation not triggered");

2577

2578

2579

5

    Ok(())

2580

5

2581

2582

3

pub fn blocking_unique_view_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

2583

3

    let first_doc = db.collection::<Unique>().push(&Unique::new("1"))?;

2584

2585

    if let Err(Error::UniqueKeyViolation {

2586

3

        view,

2587

3

        existing_document,

2588

3

        conflicting_document,

2589

3

    }) = db.collection::<Unique>().push(&Unique::new("1"))

2590

2591

3

        assert_eq!(view, UniqueValue.view_name());

2592

3

        assert_eq!(first_doc.id, existing_document.id.deserialize()?);

2593

        // We can't predict the conflicting document id since it's generated

2594

        // inside of the transaction, but we can assert that it's different than

2595

        // the document that was previously stored.

2596

3

        assert_ne!(conflicting_document, existing_document);

2597

    } else {

2598

        unreachable!("unique key violation not triggered");

2599

2600

2601

3

    let second_doc = db.collection::<Unique>().push(&Unique::new("2"))?;

2602

3

    let mut second_doc = db.collection::<Unique>().get(&second_doc.id)?.unwrap();

2603

3

    let mut contents = Unique::document_contents(&second_doc)?;

2604

3

    contents.value = String::from("1");

2605

3

    Unique::set_document_contents(&mut second_doc, contents)?;

2606

    if let Err(Error::UniqueKeyViolation {

2607

3

        view,

2608

3

        existing_document,

2609

3

        conflicting_document,

2610

3

    }) = db.update::<Unique, _>(&mut second_doc)

2611

2612

3

        assert_eq!(view, UniqueValue.view_name());

2613

3

        assert_eq!(first_doc.id, existing_document.id.deserialize()?);

2614

3

        assert_eq!(conflicting_document.id, second_doc.header.id);

2615

    } else {

2616

        unreachable!("unique key violation not triggered");

2617

2618

2619

3

    Ok(())

2620

3

2621

2622

3

pub fn blocking_cow_views<C: Connection>(db: &C) -> anyhow::Result<()> {

2623

3

    db.collection::<Basic>()

2624

3

        .push(&Basic::new("test").with_category("category"))?;

2625

2626

3

    let mapping = BasicByCategoryCow::entries(db)

2627

3

        .query()?

2628

3

        .into_iter()

2629

3

        .next()

2630

3

        .expect("mapping not found");

2631

3

    assert_eq!(mapping.key, "category");

2632

3

    assert_eq!(BasicByCategoryCow::entries(db).reduce()?, 1);

2633

2634

3

    Ok(())

2635

3

2636

2637

5

pub async fn named_collection_tests<C: AsyncConnection>(db: &C) -> anyhow::Result<()> {

2638

5

    Unique::new("0").push_into_async(db).await?;

2639

5

    let original_entry = Unique::entry_async("1", db)

2640

5

        .update_with(|_existing: &mut Unique| unreachable!())

2641

5

        .or_insert_with(|| Unique::new("1"))

2642

15

        .await?

2643

5

        .expect("Document not inserted");

2644

2645

5

    let updated = Unique::entry_async("1", db)

2646

5

        .update_with(|existing: &mut Unique| {

2647

5

            existing.value = String::from("2");

2648

5

})

2649

5

        .or_insert_with(|| unreachable!())

2650

15

        .await?

2651

5

        .unwrap();

2652

5

    assert_eq!(original_entry.header.id, updated.header.id);

2653

5

    assert_ne!(original_entry.contents.value, updated.contents.value);

2654

2655

10

    let retrieved = Unique::entry_async("2", db).await?.unwrap();

2656

5

    assert_eq!(retrieved.contents.value, updated.contents.value);

2657

2658

5

    let conflict = Unique::entry_async("2", db)

2659

5

        .update_with(|existing: &mut Unique| {

2660

5

            existing.value = String::from("0");

2661

5

})

2662

15

        .await;

2663

5

    assert!(matches!(conflict, Err(Error::UniqueKeyViolation { .. })));

2664

2665

5

    Ok(())

2666

5

2667

2668

3

pub fn blocking_named_collection_tests<C: Connection>(db: &C) -> anyhow::Result<()> {

2669

3

    Unique::new("0").push_into(db)?;

2670

3

    let original_entry = Unique::entry("1", db)

2671

3

        .update_with(|_existing: &mut Unique| unreachable!())

2672

3

        .or_insert_with(|| Unique::new("1"))

2673

3

        .execute()?

2674

3

        .expect("Document not inserted");

2675

2676

3

    let updated = Unique::entry("1", db)

2677

3

        .update_with(|existing: &mut Unique| {

2678

3

            existing.value = String::from("2");

2679

3

})

2680

3

        .or_insert_with(|| unreachable!())

2681

3

        .execute()?

2682

3

        .unwrap();

2683

3

    assert_eq!(original_entry.header.id, updated.header.id);

2684

3

    assert_ne!(original_entry.contents.value, updated.contents.value);

2685

2686

3

    let retrieved = Unique::entry("2", db).execute()?.unwrap();

2687

3

    assert_eq!(retrieved.contents.value, updated.contents.value);

2688

2689

3

    let conflict = Unique::entry("2", db)

2690

3

        .update_with(|existing: &mut Unique| {

2691

3

            existing.value = String::from("0");

2692

3

})

2693

3

        .execute();

2694

3

    assert!(matches!(conflict, Err(Error::UniqueKeyViolation { .. })));

2695

2696

3

    Ok(())

2697

3

2698

2699

5

pub async fn compaction_tests<C: AsyncConnection + AsyncKeyValue>(db: &C) -> anyhow::Result<()> {

2700

5

    let original_value = Basic::new("initial_value");

2701

5

    let collection = db.collection::<Basic>();

2702

5

    collection.push(&original_value).await?;

2703

2704

    // Test a collection compaction

2705

5

    db.compact_collection::<Basic>().await?;

2706

2707

    // Test the key value store compaction

2708

5

    db.set_key("foo", &1_u32).await?;

2709

5

    db.compact_key_value_store().await?;

2710

2711

    // Compact everything... again...

2712

5

    db.compact().await?;

2713

2714

5

    Ok(())

2715

5

2716

2717

3

pub fn blocking_compaction_tests<C: Connection + KeyValue>(db: &C) -> anyhow::Result<()> {

2718

3

    let original_value = Basic::new("initial_value");

2719

3

    let collection = db.collection::<Basic>();

2720

3

    collection.push(&original_value)?;

2721

2722

    // Test a collection compaction

2723

3

    db.compact_collection::<Basic>()?;

2724

2725

    // Test the key value store compaction

2726

3

    db.set_key("foo", &1_u32).execute()?;

2727

3

    db.compact_key_value_store()?;

2728

2729

    // Compact everything... again...

2730

3

    db.compact()?;

2731

2732

3

    Ok(())

2733

3

2734

2735

5

pub async fn user_management_tests<C: AsyncConnection, S: AsyncStorageConnection>(

2736

5

    admin: &C,

2737

5

    server: S,

2738

5

    server_name: &str,

2739

5

) -> anyhow::Result<()> {

2740

5

    let username = format!("user-management-tests-{server_name}");

2741

5

    let user_id = server.create_user(&username).await?;

2742

    // Test the default created user state.

2743

2744

5

        let user = User::get_async(&user_id, admin)

2745

5

            .await

2746

5

            .unwrap()

2747

5

            .expect("user not found");

2748

5

        assert_eq!(user.contents.username, username);

2749

5

        assert!(user.contents.groups.is_empty());

2750

5

        assert!(user.contents.roles.is_empty());

2751

2752

2753

5

    let role = Role::named(format!("role-{server_name}"))

2754

5

        .push_into_async(admin)

2755

5

        .await

2756

5

        .unwrap();

2757

5

    let group = PermissionGroup::named(format!("group-{server_name}"))

2758

5

        .push_into_async(admin)

2759

5

        .await

2760

5

        .unwrap();

2761

5

2762

5

    // Add the role and group.

2763

5

    server

2764

5

        .add_permission_group_to_user(user_id, &group)

2765

5

        .await

2766

5

        .unwrap();

2767

5

    server.add_role_to_user(user_id, &role).await.unwrap();

2768

2769

    // Test the results

2770

2771

5

        let user = User::get_async(&user_id, admin)

2772

5

            .await

2773

5

            .unwrap()

2774

5

            .expect("user not found");

2775

5

        assert_eq!(user.contents.groups, vec![group.header.id]);

2776

5

        assert_eq!(user.contents.roles, vec![role.header.id]);

2777

2778

2779

    // Add the same things again (should not do anything). With names this time.

2780

5

    server

2781

5

        .add_permission_group_to_user(&username, &group)

2782

5

        .await

2783

5

        .unwrap();

2784

5

    server.add_role_to_user(&username, &role).await.unwrap();

2785

2786

5

        let user = User::load_async(&username, admin)

2787

10

            .await

2788

5

            .unwrap()

2789

5

            .expect("user not found");

2790

5

        assert_eq!(user.contents.groups, vec![group.header.id]);

2791

5

        assert_eq!(user.contents.roles, vec![role.header.id]);

2792

2793

2794

    // Remove the group.

2795

5

    server

2796

5

        .remove_permission_group_from_user(user_id, &group)

2797

5

        .await

2798

5

        .unwrap();

2799

5

    server.remove_role_from_user(user_id, &role).await.unwrap();

2800

2801

5

        let user = User::get_async(&user_id, admin)

2802

5

            .await

2803

5

            .unwrap()

2804

5

            .expect("user not found");

2805

5

        assert!(user.contents.groups.is_empty());

2806

5

        assert!(user.contents.roles.is_empty());

2807

2808

2809

    // Removing again shouldn't cause an error.

2810

5

    server

2811

5

        .remove_permission_group_from_user(user_id, &group)

2812

5

        .await?;

2813

5

    server.remove_role_from_user(user_id, &role).await?;

2814

2815

    // Remove the user

2816

5

    server.delete_user(user_id).await?;

2817

    // Test if user is removed.

2818

2819

5

    assert!(User::get_async(&user_id, admin).await.unwrap().is_none());

2820

2821

5

    Ok(())

2822

5

2823

2824

3

pub fn blocking_user_management_tests<C: Connection, S: StorageConnection>(

2825

3

    admin: &C,

2826

3

    server: &S,

2827

3

    server_name: &str,

2828

3

) -> anyhow::Result<()> {

2829

3

    let username = format!("user-management-tests-{server_name}");

2830

3

    let user_id = server.create_user(&username)?;

2831

    // Test the default created user state.

2832

2833

3

        let user = User::get(&user_id, admin).unwrap().expect("user not found");

2834

3

        assert_eq!(user.contents.username, username);

2835

3

        assert!(user.contents.groups.is_empty());

2836

3

        assert!(user.contents.roles.is_empty());

2837

2838

2839

3

    let role = Role::named(format!("role-{server_name}"))

2840

3

        .push_into(admin)

2841

3

        .unwrap();

2842

3

    let group = PermissionGroup::named(format!("group-{server_name}"))

2843

3

        .push_into(admin)

2844

3

        .unwrap();

2845

3

2846

3

    // Add the role and group.

2847

3

    server

2848

3

        .add_permission_group_to_user(user_id, &group)

2849

3

        .unwrap();

2850

3

    server.add_role_to_user(user_id, &role).unwrap();

2851

3

2852

3

    // Test the results

2853

3

2854

3

        let user = User::get(&user_id, admin).unwrap().expect("user not found");

2855

3

        assert_eq!(user.contents.groups, vec![group.header.id]);

2856

3

        assert_eq!(user.contents.roles, vec![role.header.id]);

2857

2858

2859

    // Add the same things again (should not do anything). With names this time.

2860

3

    server

2861

3

        .add_permission_group_to_user(&username, &group)

2862

3

        .unwrap();

2863

3

    server.add_role_to_user(&username, &role).unwrap();

2864

3

2865

3

        let user = User::load(&username, admin)

2866

3

            .unwrap()

2867

3

            .expect("user not found");

2868

3

        assert_eq!(user.contents.groups, vec![group.header.id]);

2869

3

        assert_eq!(user.contents.roles, vec![role.header.id]);

2870

2871

2872

    // Remove the group.

2873

3

    server

2874

3

        .remove_permission_group_from_user(user_id, &group)

2875

3

        .unwrap();

2876

3

    server.remove_role_from_user(user_id, &role).unwrap();

2877

3

2878

3

        let user = User::get(&user_id, admin).unwrap().expect("user not found");

2879

3

        assert!(user.contents.groups.is_empty());

2880

3

        assert!(user.contents.roles.is_empty());

2881

2882

2883

    // Removing again shouldn't cause an error.

2884

3

    server.remove_permission_group_from_user(user_id, &group)?;

2885

3

    server.remove_role_from_user(user_id, &role)?;

2886

2887

    // Remove the user

2888

3

    server.delete_user(user_id)?;

2889

    // Test if user is removed.

2890

2891

3

    assert!(User::get(&user_id, admin).unwrap().is_none());

2892

2893

3

    Ok(())

2894

3

2895

2896

#[cfg(feature = "token-authentication")]

2897

5

pub async fn token_authentication_tests<C: AsyncConnection, S: AsyncStorageConnection>(

2898

5

    admin: &C,

2899

5

    server: &S,

2900

5

    server_name: &str,

2901

5

) -> anyhow::Result<()> {

2902

5

    let username = format!("token-authentication-tests-{server_name}");

2903

5

    let user_id = server.create_user(&username).await?;

2904

5

    let user_token =

2905

10

        AuthenticationToken::create_async(IdentityReference::user(&username)?, admin).await?;

2906

2907

5

    let as_user = server

2908

5

        .authenticate_with_token(user_token.header.id, &user_token.contents.token)

2909

10

        .await?;

2910

5

    let identity = as_user.session().and_then(Session::identity);

2911

5

    if let Some(Identity::User { id, .. }) = identity {

2912

5

        assert_eq!(*id, user_id);

2913

2914

2915

5

    let role = Role::named(format!("token-role-{server_name}"))

2916

5

        .push_into_async(admin)

2917

5

        .await

2918

5

        .unwrap();

2919

5

    let role_token =

2920

5

        AuthenticationToken::create_async(IdentityReference::role(role.header.id)?, admin).await?;

2921

2922

5

    let as_role = server

2923

5

        .authenticate_with_token(role_token.header.id, &role_token.contents.token)

2924

10

        .await?;

2925

5

    let identity = as_role.session().and_then(Session::identity);

2926

5

    if let Some(Identity::Role { id, .. }) = identity {

2927

5

        assert_eq!(*id, role.header.id);

2928

2929

2930

5

    Ok(())

2931

5

2932

2933

#[cfg(feature = "token-authentication")]

2934

3

pub fn blocking_token_authentication_tests<C: Connection, S: StorageConnection>(

2935

3

    admin: &C,

2936

3

    server: &S,

2937

3

    server_name: &str,

2938

3

) -> anyhow::Result<()> {

2939

3

    let username = format!("blocking-token-authentication-tests-{server_name}");

2940

3

    let user_id = server.create_user(&username)?;

2941

3

    let user_token = AuthenticationToken::create(&IdentityReference::user(&username)?, admin)?;

2942

2943

3

    let as_user =

2944

3

        server.authenticate_with_token(user_token.header.id, &user_token.contents.token)?;

2945

3

    let identity = as_user.session().and_then(Session::identity);

2946

3

    if let Some(Identity::User { id, .. }) = identity {

2947

3

        assert_eq!(*id, user_id);

2948

2949

2950

3

    let role = Role::named(format!("token-role-{server_name}"))

2951

3

        .push_into(admin)

2952

3

        .unwrap();

2953

3

    let role_token = AuthenticationToken::create(&IdentityReference::role(role.header.id)?, admin)?;

2954

2955

3

    let as_role =

2956

3

        server.authenticate_with_token(role_token.header.id, &role_token.contents.token)?;

2957

3

    let identity = as_role.session().and_then(Session::identity);

2958

3

    if let Some(Identity::Role { id, .. }) = identity {

2959

3

        assert_eq!(*id, role.header.id);

2960

2961

2962

3

    Ok(())

2963

3

2964

2965

/// Defines the `KeyValue` test suite

2966

#[macro_export]

2967

macro_rules! define_async_kv_test_suite {

2968

    ($harness:ident) => {

2969

        #[cfg(test)]

2970

        mod r#async_kv {

2971

            use super::$harness;

2972

            #[tokio::test]

2973

5

            async fn basic_kv_test() -> anyhow::Result<()> {

2974

5

                use $crate::keyvalue::{AsyncKeyValue, KeyStatus};

2975

5

                let harness = $harness::new($crate::test_util::HarnessTest::KvBasic).await?;

2976

5

                let db = harness.connect().await?;

2977

5

                assert_eq!(

2978

5

                    db.set_key("akey", &String::from("avalue")).await?,

2979

5

                    KeyStatus::Inserted

2980

5

);

2981

5

                assert_eq!(

2982

5

                    db.get_key("akey").into().await?,

2983

5

                    Some(String::from("avalue"))

2984

5

);

2985

5

                assert_eq!(

2986

5

                    db.set_key("akey", &String::from("new_value"))

2987

5

                        .returning_previous_as()

2988

5

                        .await?,

2989

5

                    Some(String::from("avalue"))

2990

5

);

2991

5

                assert_eq!(

2992

5

                    db.get_key("akey").into().await?,

2993

5

                    Some(String::from("new_value"))

2994

5

);

2995

5

                assert_eq!(

2996

5

                    db.get_key("akey").and_delete().into().await?,

2997

5

                    Some(String::from("new_value"))

2998

5

);

2999

5

                assert_eq!(db.get_key("akey").await?, None);

3000

5

                assert_eq!(

3001

5

                    db.set_key("akey", &String::from("new_value"))

3002

5

                        .returning_previous()

3003

5

                        .await?,

3004

5

                    None

3005

5

);

3006

5

                assert_eq!(db.delete_key("akey").await?, KeyStatus::Deleted);

3007

5

                assert_eq!(db.delete_key("akey").await?, KeyStatus::NotChanged);

3008

5

3009

5

                harness.shutdown().await?;

3010

5

3011

5

                Ok(())

3012

5

3013

3014

            #[tokio::test]

3015

5

            async fn kv_concurrency() -> anyhow::Result<()> {

3016

5

                use $crate::keyvalue::{AsyncKeyValue, KeyStatus};

3017

5

                const WRITERS: usize = 100;

3018

5

                const INCREMENTS: usize = 100;

3019

5

                let harness = $harness::new($crate::test_util::HarnessTest::KvConcurrency).await?;

3020

5

                let db = harness.connect().await?;

3021

5

3022

5

                let handles = (0..WRITERS).map(|_| {

3023

5

                    let db = db.clone();

3024

5

                    tokio::task::spawn(async move {

3025

5

                        for _ in 0..INCREMENTS {

3026

5

                            db.increment_key_by("concurrency", 1_u64).await.unwrap();

3027

5

3028

5

})

3029

5

});

3030

5

                futures::future::join_all(handles).await;

3031

5

3032

5

                assert_eq!(

3033

5

                    db.get_key("concurrency").into_u64().await.unwrap().unwrap(),

3034

5

                    (WRITERS * INCREMENTS) as u64

3035

5

);

3036

5

3037

5

                harness.shutdown().await?;

3038

5

3039

5

                Ok(())

3040

5

3041

3042

            #[tokio::test]

3043

5

            async fn kv_set_tests() -> anyhow::Result<()> {

3044

5

                use $crate::keyvalue::{AsyncKeyValue, KeyStatus};

3045

5

                let harness = $harness::new($crate::test_util::HarnessTest::KvSet).await?;

3046

5

                let db = harness.connect().await?;

3047

5

                let kv = db.with_key_namespace("set");

3048

5

3049

5

                assert_eq!(

3050

5

                    kv.set_key("a", &0_u32).only_if_exists().await?,

3051

5

                    KeyStatus::NotChanged

3052

5

);

3053

5

                assert_eq!(

3054

5

                    kv.set_key("a", &0_u32).only_if_vacant().await?,

3055

5

                    KeyStatus::Inserted

3056

5

);

3057

5

                assert_eq!(

3058

5

                    kv.set_key("a", &1_u32).only_if_vacant().await?,

3059

5

                    KeyStatus::NotChanged

3060

5

);

3061

5

                assert_eq!(

3062

5

                    kv.set_key("a", &2_u32).only_if_exists().await?,

3063

5

                    KeyStatus::Updated,

3064

5

);

3065

5

                assert_eq!(

3066

5

                    kv.set_key("a", &3_u32).returning_previous_as().await?,

3067

5

                    Some(2_u32),

3068

5

);

3069

5

3070

5

                harness.shutdown().await?;

3071

5

3072

5

                Ok(())

3073

5

3074

3075

            #[tokio::test]

3076

5

            async fn kv_increment_decrement_tests() -> anyhow::Result<()> {

3077

5

                use $crate::keyvalue::{AsyncKeyValue, KeyStatus};

3078

5

                let harness =

3079

5

                    $harness::new($crate::test_util::HarnessTest::KvIncrementDecrement).await?;

3080

5

                let db = harness.connect().await?;

3081

5

                let kv = db.with_key_namespace("increment_decrement");

3082

5

3083

5

                // Empty keys should be equal to 0

3084

5

                assert_eq!(kv.increment_key_by("i64", 1_i64).await?, 1_i64);

3085

5

                assert_eq!(kv.get_key("i64").into_i64().await?, Some(1_i64));

3086

5

                assert_eq!(kv.increment_key_by("u64", 1_u64).await?, 1_u64);

3087

5

                $crate::assert_f64_eq!(kv.increment_key_by("f64", 1_f64).await?, 1_f64);

3088

5

3089

5

                // Test float incrementing/decrementing an existing value

3090

5

                $crate::assert_f64_eq!(kv.increment_key_by("f64", 1_f64).await?, 2_f64);

3091

5

                $crate::assert_f64_eq!(kv.decrement_key_by("f64", 2_f64).await?, 0_f64);

3092

5

3093

5

                // Empty keys should be equal to 0

3094

5

                assert_eq!(kv.decrement_key_by("i64_2", 1_i64).await?, -1_i64);

3095

5

                assert_eq!(

3096

5

                    kv.decrement_key_by("u64_2", 42_u64)

3097

5

                        .allow_overflow()

3098

5

                        .await?,

3099

5

                    u64::MAX - 41

3100

5

);

3101

5

                assert_eq!(kv.decrement_key_by("u64_3", 42_u64).await?, u64::MIN);

3102

5

                $crate::assert_f64_eq!(kv.decrement_key_by("f64_2", 1_f64).await?, -1_f64);

3103

5

3104

5

                // Test decrement wrapping with overflow

3105

5

                kv.set_numeric_key("i64", i64::MIN).await?;

3106

5

                assert_eq!(

3107

5

                    kv.decrement_key_by("i64", 1_i64).allow_overflow().await?,

3108

5

                    i64::MAX

3109

5

);

3110

5

                assert_eq!(

3111

5

                    kv.decrement_key_by("u64", 2_u64).allow_overflow().await?,

3112

5

                    u64::MAX

3113

5

);

3114

5

3115

5

                // Test increment wrapping with overflow

3116

5

                assert_eq!(

3117

5

                    kv.increment_key_by("i64", 1_i64).allow_overflow().await?,

3118

5

                    i64::MIN

3119

5

);

3120

5

                assert_eq!(

3121

5

                    kv.increment_key_by("u64", 1_u64).allow_overflow().await?,

3122

5

                    u64::MIN

3123

5

);

3124

5

3125

5

                // Test saturating increments.

3126

5

                kv.set_numeric_key("i64", i64::MAX - 1).await?;

3127

5

                kv.set_numeric_key("u64", u64::MAX - 1).await?;

3128

5

                assert_eq!(kv.increment_key_by("i64", 2_i64).await?, i64::MAX);

3129

5

                assert_eq!(kv.increment_key_by("u64", 2_u64).await?, u64::MAX);

3130

5

3131

5

                // Test saturating decrements.

3132

5

                kv.set_numeric_key("i64", i64::MIN + 1).await?;

3133

5

                kv.set_numeric_key("u64", u64::MIN + 1).await?;

3134

5

                assert_eq!(kv.decrement_key_by("i64", 2_i64).await?, i64::MIN);

3135

5

                assert_eq!(kv.decrement_key_by("u64", 2_u64).await?, u64::MIN);

3136

5

3137

5

                // Test numerical conversion safety using get

3138

5

3139

5

                    // For i64 -> f64, the limit is 2^52 + 1 in either posive or

3140

5

                    // negative directions.

3141

5

                    kv.set_numeric_key("i64", (2_i64.pow(f64::MANTISSA_DIGITS)))

3142

5

                        .await?;

3143

5

                    $crate::assert_f64_eq!(

3144

5

                        kv.get_key("i64").into_f64().await?.unwrap(),

3145

5

                        9_007_199_254_740_992_f64

3146

5

);

3147

5

                    kv.set_numeric_key("i64", -(2_i64.pow(f64::MANTISSA_DIGITS)))

3148

5

                        .await?;

3149

5

                    $crate::assert_f64_eq!(

3150

5

                        kv.get_key("i64").into_f64().await?.unwrap(),

3151

5

                        -9_007_199_254_740_992_f64

3152

5

);

3153

5

3154

5

                    kv.set_numeric_key("i64", (2_i64.pow(f64::MANTISSA_DIGITS) + 1))

3155

5

                        .await?;

3156

5

                    assert!(kv.get_key("i64").into_f64().await.is_err());

3157

5

                    $crate::assert_f64_eq!(

3158

5

                        kv.get_key("i64").into_f64_lossy().await?.unwrap(),

3159

5

                        9_007_199_254_740_993_f64

3160

5

);

3161

5

                    kv.set_numeric_key("i64", -(2_i64.pow(f64::MANTISSA_DIGITS) + 1))

3162

5

                        .await?;

3163

5

                    assert!(kv.get_key("i64").into_f64().await.is_err());

3164

5

                    $crate::assert_f64_eq!(

3165

5

                        kv.get_key("i64").into_f64_lossy().await?.unwrap(),

3166

5

                        -9_007_199_254_740_993_f64

3167

5

);

3168

5

3169

5

                    // For i64 -> u64, the only limit is sign.

3170

5

                    kv.set_numeric_key("i64", -1_i64).await?;

3171

5

                    assert!(kv.get_key("i64").into_u64().await.is_err());

3172

5

                    assert_eq!(

3173

5

                        kv.get_key("i64").into_u64_lossy(true).await?.unwrap(),

3174

5

                        0_u64

3175

5

);

3176

5

                    assert_eq!(

3177

5

                        kv.get_key("i64").into_u64_lossy(false).await?.unwrap(),

3178

5

                        u64::MAX

3179

5

);

3180

5

3181

5

                    // For f64 -> i64, the limit is fractional numbers. Saturating isn't tested in this conversion path.

3182

5

                    kv.set_numeric_key("f64", 1.1_f64).await?;

3183

5

                    assert!(kv.get_key("f64").into_i64().await.is_err());

3184

5

                    assert_eq!(

3185

5

                        kv.get_key("f64").into_i64_lossy(false).await?.unwrap(),

3186

5

                        1_i64

3187

5

);

3188

5

                    kv.set_numeric_key("f64", -1.1_f64).await?;

3189

5

                    assert!(kv.get_key("f64").into_i64().await.is_err());

3190

5

                    assert_eq!(

3191

5

                        kv.get_key("f64").into_i64_lossy(false).await?.unwrap(),

3192

5

                        -1_i64

3193

5

);

3194

5

3195

5

                    // For f64 -> u64, the limit is fractional numbers or negative numbers. Saturating isn't tested in this conversion path.

3196

5

                    kv.set_numeric_key("f64", 1.1_f64).await?;

3197

5

                    assert!(kv.get_key("f64").into_u64().await.is_err());

3198

5

                    assert_eq!(

3199

5

                        kv.get_key("f64").into_u64_lossy(false).await?.unwrap(),

3200

5

                        1_u64

3201

5

);

3202

5

                    kv.set_numeric_key("f64", -1.1_f64).await?;

3203

5

                    assert!(kv.get_key("f64").into_u64().await.is_err());

3204

5

                    assert_eq!(

3205

5

                        kv.get_key("f64").into_u64_lossy(false).await?.unwrap(),

3206

5

                        0_u64

3207

5

);

3208

5

3209

5

                    // For u64 -> i64, the limit is > i64::MAX

3210

5

                    kv.set_numeric_key("u64", i64::MAX as u64 + 1).await?;

3211

5

                    assert!(kv.get_key("u64").into_i64().await.is_err());

3212

5

                    assert_eq!(

3213

5

                        kv.get_key("u64").into_i64_lossy(true).await?.unwrap(),

3214

5

                        i64::MAX

3215

5

);

3216

5

                    assert_eq!(

3217

5

                        kv.get_key("u64").into_i64_lossy(false).await?.unwrap(),

3218

5

                        i64::MIN

3219

5

);

3220

5

3221

5

3222

5

                // Test that non-numeric keys won't be changed when attempting to incr/decr

3223

5

                kv.set_key("non-numeric", &String::from("test")).await?;

3224

5

                assert!(kv.increment_key_by("non-numeric", 1_i64).await.is_err());

3225

5

                assert!(kv.decrement_key_by("non-numeric", 1_i64).await.is_err());

3226

5

                assert_eq!(

3227

5

                    kv.get_key("non-numeric").into::<String>().await?.unwrap(),

3228

5

                    String::from("test")

3229

5

);

3230

5

3231

5

                // Test that NaN cannot be stored

3232

5

                kv.set_numeric_key("f64", 0_f64).await?;

3233

5

                assert!(matches!(

3234

5

                    kv.set_numeric_key("f64", f64::NAN).await,

3235

5

                    Err(bonsaidb_core::Error::NotANumber)

3236

5

));

3237

5

                // Verify the value was unchanged.

3238

5

                $crate::assert_f64_eq!(kv.get_key("f64").into_f64().await?.unwrap(), 0.);

3239

5

                // Try to increment by nan

3240

5

                assert!(matches!(

3241

5

                    kv.increment_key_by("f64", f64::NAN).await,

3242

5

                    Err(bonsaidb_core::Error::NotANumber)

3243

5

));

3244

5

                $crate::assert_f64_eq!(kv.get_key("f64").into_f64().await?.unwrap(), 0.);

3245

5

3246

5

                harness.shutdown().await?;

3247

5

3248

5

                Ok(())

3249

5

3250

3251

            #[tokio::test]

3252

5

            async fn kv_expiration_tests() -> anyhow::Result<()> {

3253

5

                use std::time::Duration;

3254

5

3255

5

                use $crate::keyvalue::{AsyncKeyValue, KeyStatus};

3256

5

3257

5

                let harness = $harness::new($crate::test_util::HarnessTest::KvExpiration).await?;

3258

5

                let db = harness.connect().await?;

3259

5

3260

5

                loop {

3261

5

                    let kv = db.with_key_namespace("expiration");

3262

5

3263

5

                    kv.delete_key("a").await?;

3264

5

                    kv.delete_key("b").await?;

3265

5

3266

5

                    // Test that the expiration is updated for key a, but not for key b.

3267

5

                    let timing = $crate::test_util::TimingTest::new(Duration::from_millis(500));

3268

5

                    let (r1, r2) = tokio::join!(

3269

5

                        kv.set_key("a", &0_u32).expire_in(Duration::from_secs(2)),

3270

5

                        kv.set_key("b", &0_u32).expire_in(Duration::from_secs(2))

3271

5

);

3272

5

                    if timing.elapsed() > Duration::from_millis(500) {

3273

5

                        println!(

3274

5

                            "Restarting test {}. Took too long {:?}",

3275

5

                            line!(),

3276

5

                            timing.elapsed(),

3277

5

);

3278

5

                        continue;

3279

5

3280

5

                    assert_eq!(r1?, KeyStatus::Inserted);

3281

5

                    assert_eq!(r2?, KeyStatus::Inserted);

3282

5

                    let (r1, r2) = tokio::join!(

3283

5

                        kv.set_key("a", &1_u32).expire_in(Duration::from_secs(4)),

3284

5

                        kv.set_key("b", &1_u32)

3285

5

                            .expire_in(Duration::from_secs(100))

3286

5

                            .keep_existing_expiration()

3287

5

);

3288

5

                    if timing.elapsed() > Duration::from_secs(1) {

3289

5

                        println!(

3290

5

                            "Restarting test {}. Took too long {:?}",

3291

5

                            line!(),

3292

5

                            timing.elapsed(),

3293

5

);

3294

5

                        continue;

3295

5

3296

5

3297

5

                    assert_eq!(r1?, KeyStatus::Updated, "a wasn't an update");

3298

5

                    assert_eq!(r2?, KeyStatus::Updated, "b wasn't an update");

3299

5

3300

5

                    let a = kv.get_key("a").into().await?;

3301

5

                    assert_eq!(a, Some(1u32), "a shouldn't have expired yet");

3302

5

3303

5

                    // Before checking the value, make sure we haven't elapsed too

3304

5

                    // much time. If so, just restart the test.

3305

5

                    if !timing.wait_until_async(Duration::from_secs_f32(3.)).await {

3306

5

                        println!(

3307

5

                            "Restarting test {}. Took too long {:?}",

3308

5

                            line!(),

3309

5

                            timing.elapsed()

3310

5

);

3311

5

                        continue;

3312

5

3313

5

3314

5

                    assert_eq!(kv.get_key("b").await?, None, "b never expired");

3315

5

3316

5

                    timing.wait_until_async(Duration::from_secs_f32(5.)).await;

3317

5

                    assert_eq!(kv.get_key("a").await?, None, "a never expired");

3318

5

                    break;

3319

5

3320

5

                harness.shutdown().await?;

3321

5

3322

5

                Ok(())

3323

5

3324

3325

            #[tokio::test]

3326

5

            async fn delete_expire_tests() -> anyhow::Result<()> {

3327

5

                use std::time::Duration;

3328

5

3329

5

                use $crate::keyvalue::{AsyncKeyValue, KeyStatus};

3330

5

3331

5

                let harness = $harness::new($crate::test_util::HarnessTest::KvDeleteExpire).await?;

3332

5

                let db = harness.connect().await?;

3333

5

3334

5

                loop {

3335

5

                    let kv = db.with_key_namespace("delete_expire");

3336

5

3337

5

                    kv.delete_key("a").await?;

3338

5

3339

5

                    let timing = $crate::test_util::TimingTest::new(Duration::from_millis(100));

3340

5

3341

5

                    // Create a key with an expiration. Delete the key. Set a new

3342

5

                    // value at that key with no expiration. Ensure it doesn't

3343

5

                    // expire.

3344

5

                    kv.set_key("a", &0_u32)

3345

5

                        .expire_in(Duration::from_secs(2))

3346

5

                        .await?;

3347

5

                    kv.delete_key("a").await?;

3348

5

                    kv.set_key("a", &1_u32).await?;

3349

5

                    if timing.elapsed() > Duration::from_secs(1) {

3350

5

                        println!(

3351

5

                            "Restarting test {}. Took too long {:?}",

3352

5

                            line!(),

3353

5

                            timing.elapsed(),

3354

5

);

3355

5

                        continue;

3356

5

3357

5

                    if !timing.wait_until_async(Duration::from_secs_f32(2.5)).await {

3358

5

                        println!(

3359

5

                            "Restarting test {}. Took too long {:?}",

3360

5

                            line!(),

3361

5

                            timing.elapsed()

3362

5

);

3363

5

                        continue;

3364

5

3365

5

3366

5

                    assert_eq!(kv.get_key("a").into().await?, Some(1u32));

3367

5

3368

5

                    break;

3369

5

3370

5

                harness.shutdown().await?;

3371

5

3372

5

                Ok(())

3373

5

3374

3375

            #[tokio::test]

3376

            // This test can fail when the machine its running on is under high load or

3377

            // constrained resources. We need a command that persists (and waits until

3378

            // persist) to make this test fully deterministic.

3379

5

            async fn kv_transaction_tests() -> anyhow::Result<()> {

3380

5

                use std::time::Duration;

3381

5

3382

5

                use $crate::connection::AsyncConnection;

3383

5

                use $crate::keyvalue::{AsyncKeyValue, KeyStatus};

3384

5

                // loop {

3385

5

                let harness = $harness::new($crate::test_util::HarnessTest::KvTransactions).await?;

3386

5

                let db = harness.connect().await?;

3387

5

                // Generate several transactions that we can validate. Persisting

3388

5

                // happens in the background, so we delay between each step to give

3389

5

                // it a moment.

3390

5

                db.set_key("expires", &0_u32)

3391

5

                    .expire_in(Duration::from_secs(1))

3392

5

                    .await?;

3393

5

                db.set_key("akey", &String::from("avalue")).await?;

3394

5

                db.set_numeric_key("nkey", 0_u64).await?;

3395

5

                tokio::time::sleep(Duration::from_millis(500)).await;

3396

5

                db.increment_key_by("nkey", 1_u64).await?;

3397

5

                tokio::time::sleep(Duration::from_millis(500)).await;

3398

5

                db.delete_key("nkey").await?;

3399

5

                db.get_key("akey").and_delete().await?;

3400

5

                tokio::time::sleep(Duration::from_millis(500)).await;

3401

5

                // Ensure this doesn't generate a transaction.

3402

5

                db.delete_key("nkey").await?;

3403

5

3404

5

                tokio::time::sleep(Duration::from_secs(1)).await;

3405

5

3406

5

                let transactions =

3407

5

                    AsyncConnection::list_executed_transactions(&db, None, None).await?;

3408

5

                let deleted_keys = transactions

3409

5

                    .iter()

3410

5

                    .filter_map(|tx| tx.changes.keys())

3411

5

                    .flatten()

3412

5

                    .filter(|changed_key| dbg!(changed_key).deleted)

3413

5

                    .count();

3414

5

                assert_eq!(deleted_keys, 3, "deleted keys wasn't 3");

3415

5

                let akey_changes = transactions

3416

5

                    .iter()

3417

5

                    .filter_map(|tx| tx.changes.keys())

3418

5

                    .flatten()

3419

5

                    .filter(|changed_key| changed_key.key == "akey")

3420

5

                    .count();

3421

5

                assert_eq!(akey_changes, 2, "akey changes wasn't 2");

3422

5

                let nkey_changes = transactions

3423

5

                    .iter()

3424

5

                    .filter_map(|tx| tx.changes.keys())

3425

5

                    .flatten()

3426

5

                    .filter(|changed_key| changed_key.key == "nkey")

3427

5

                    .count();

3428

5

                assert_eq!(nkey_changes, 3, "nkey changes wasn't 3");

3429

5

3430

5

                harness.shutdown().await?;

3431

5

                // }

3432

5

3433

5

                Ok(())

3434

5

3435

3436

};

3437

3438

3439

/// Defines the `KeyValue` test suite

3440

#[macro_export]

3441

macro_rules! define_blocking_kv_test_suite {

3442

    ($harness:ident) => {

3443

        #[cfg(test)]

3444

        mod blocking_kv {

3445

            use super::$harness;

3446

3447

            #[test]

3448

3

            fn basic_kv_test() -> anyhow::Result<()> {

3449

                use $crate::keyvalue::{KeyStatus, KeyValue};

3450

3

                let harness = $harness::new($crate::test_util::HarnessTest::KvBasic)?;

3451

3

                let db = harness.connect()?;

3452

3

                assert_eq!(

3453

3

                    db.set_key("akey", &String::from("avalue")).execute()?,

3454

                    KeyStatus::Inserted

3455

);

3456

3

                assert_eq!(db.get_key("akey").into()?, Some(String::from("avalue")));

3457

3

                assert_eq!(

3458

3

                    db.set_key("akey", &String::from("new_value"))

3459

3

                        .returning_previous_as()?,

3460

3

                    Some(String::from("avalue"))

3461

);

3462

3

                assert_eq!(db.get_key("akey").into()?, Some(String::from("new_value")));

3463

3

                assert_eq!(

3464

3

                    db.get_key("akey").and_delete().into()?,

3465

3

                    Some(String::from("new_value"))

3466

);

3467

3

                assert_eq!(db.get_key("akey").query()?, None);

3468

3

                assert_eq!(

3469

3

                    db.set_key("akey", &String::from("new_value"))

3470

3

                        .returning_previous()?,

3471

                    None

3472

);

3473

3

                assert_eq!(db.delete_key("akey")?, KeyStatus::Deleted);

3474

3

                assert_eq!(db.delete_key("akey")?, KeyStatus::NotChanged);

3475

3476

3

                harness.shutdown()?;

3477

3478

3

                Ok(())

3479

3

3480

3481

            #[test]

3482

3

            fn kv_concurrency() -> anyhow::Result<()> {

3483

                use $crate::keyvalue::{KeyStatus, KeyValue};

3484

                const WRITERS: usize = 100;

3485

                const INCREMENTS: usize = 100;

3486

3

                let harness = $harness::new($crate::test_util::HarnessTest::KvConcurrency)?;

3487

3

                let db = harness.connect()?;

3488

3489

3

                let threads = (0..WRITERS)

3490

3

                    .map(|_| {

3491

                        let db = db.clone();

3492

                        std::thread::spawn(move || {

3493

                            for _ in 0..INCREMENTS {

3494

                                db.increment_key_by("concurrency", 1_u64).execute().unwrap();

3495

3496

})

3497

3

})

3498

3

                    .collect::<Vec<_>>();

3499

303

                for thread in threads {

3500

300

                    thread.join().unwrap();

3501

300

3502

3503

3

                assert_eq!(

3504

3

                    db.get_key("concurrency").into_u64().unwrap().unwrap(),

3505

3

                    (WRITERS * INCREMENTS) as u64

3506

3

);

3507

3508

3

                harness.shutdown()?;

3509

3510

3

                Ok(())

3511

3

3512

3513

            #[test]

3514

3

            fn kv_set_tests() -> anyhow::Result<()> {

3515

                use $crate::keyvalue::{KeyStatus, KeyValue};

3516

3

                let harness = $harness::new($crate::test_util::HarnessTest::KvSet)?;

3517

3

                let db = harness.connect()?;

3518

3

                let kv = db.with_key_namespace("set");

3519

3520

3

                assert_eq!(

3521

3

                    kv.set_key("a", &0_u32).only_if_exists().execute()?,

3522

                    KeyStatus::NotChanged

3523

);

3524

3

                assert_eq!(

3525

3

                    kv.set_key("a", &0_u32).only_if_vacant().execute()?,

3526

                    KeyStatus::Inserted

3527

);

3528

3

                assert_eq!(

3529

3

                    kv.set_key("a", &1_u32).only_if_vacant().execute()?,

3530

                    KeyStatus::NotChanged

3531

);

3532

3

                assert_eq!(

3533

3

                    kv.set_key("a", &2_u32).only_if_exists().execute()?,

3534

                    KeyStatus::Updated,

3535

);

3536

3

                assert_eq!(

3537

3

                    kv.set_key("a", &3_u32).returning_previous_as()?,

3538

                    Some(2_u32),

3539

);

3540

3541

3

                harness.shutdown()?;

3542

3543

3

                Ok(())

3544

3

3545

3546

            #[test]

3547

3

            fn kv_increment_decrement_tests() -> anyhow::Result<()> {

3548

                use $crate::keyvalue::{KeyStatus, KeyValue};

3549

3

                let harness = $harness::new($crate::test_util::HarnessTest::KvIncrementDecrement)?;

3550

3

                let db = harness.connect()?;

3551

3

                let kv = db.with_key_namespace("increment_decrement");

3552

3553

                // Empty keys should be equal to 0

3554

3

                assert_eq!(kv.increment_key_by("i64", 1_i64).execute()?, 1_i64);

3555

3

                assert_eq!(kv.get_key("i64").into_i64()?, Some(1_i64));

3556

3

                assert_eq!(kv.increment_key_by("u64", 1_u64).execute()?, 1_u64);

3557

3

                $crate::assert_f64_eq!(kv.increment_key_by("f64", 1_f64).execute()?, 1_f64);

3558

3559

                // Test float incrementing/decrementing an existing value

3560

3

                $crate::assert_f64_eq!(kv.increment_key_by("f64", 1_f64).execute()?, 2_f64);

3561

3

                $crate::assert_f64_eq!(kv.decrement_key_by("f64", 2_f64).execute()?, 0_f64);

3562

3563

                // Empty keys should be equal to 0

3564

3

                assert_eq!(kv.decrement_key_by("i64_2", 1_i64).execute()?, -1_i64);

3565

3

                assert_eq!(

3566

3

                    kv.decrement_key_by("u64_2", 42_u64)

3567

3

                        .allow_overflow()

3568

3

                        .execute()?,

3569

3

                    u64::MAX - 41

3570

);

3571

3

                assert_eq!(kv.decrement_key_by("u64_3", 42_u64).execute()?, u64::MIN);

3572

3

                $crate::assert_f64_eq!(kv.decrement_key_by("f64_2", 1_f64).execute()?, -1_f64);

3573

3574

                // Test decrement wrapping with overflow

3575

3

                kv.set_numeric_key("i64", i64::MIN).execute()?;

3576

3

                assert_eq!(

3577

3

                    kv.decrement_key_by("i64", 1_i64)

3578

3

                        .allow_overflow()

3579

3

                        .execute()?,

3580

                    i64::MAX

3581

);

3582

3

                assert_eq!(

3583

3

                    kv.decrement_key_by("u64", 2_u64)

3584

3

                        .allow_overflow()

3585

3

                        .execute()?,

3586

                    u64::MAX

3587

);

3588

3589

                // Test increment wrapping with overflow

3590

3

                assert_eq!(

3591

3

                    kv.increment_key_by("i64", 1_i64)

3592

3

                        .allow_overflow()

3593

3

                        .execute()?,

3594

                    i64::MIN

3595

);

3596

3

                assert_eq!(

3597

3

                    kv.increment_key_by("u64", 1_u64)

3598

3

                        .allow_overflow()

3599

3

                        .execute()?,

3600

                    u64::MIN

3601

);

3602

3603

                // Test saturating increments.

3604

3

                kv.set_numeric_key("i64", i64::MAX - 1).execute()?;

3605

3

                kv.set_numeric_key("u64", u64::MAX - 1).execute()?;

3606

3

                assert_eq!(kv.increment_key_by("i64", 2_i64).execute()?, i64::MAX);

3607

3

                assert_eq!(kv.increment_key_by("u64", 2_u64).execute()?, u64::MAX);

3608

3609

                // Test saturating decrements.

3610

3

                kv.set_numeric_key("i64", i64::MIN + 1).execute()?;

3611

3

                kv.set_numeric_key("u64", u64::MIN + 1).execute()?;

3612

3

                assert_eq!(kv.decrement_key_by("i64", 2_i64).execute()?, i64::MIN);

3613

3

                assert_eq!(kv.decrement_key_by("u64", 2_u64).execute()?, u64::MIN);

3614

3615

                // Test numerical conversion safety using get

3616

3617

                    // For i64 -> f64, the limit is 2^52 + 1 in either posive or

3618

                    // negative directions.

3619

3

                    kv.set_numeric_key("i64", (2_i64.pow(f64::MANTISSA_DIGITS)))

3620

3

                        .execute()?;

3621

3

                    $crate::assert_f64_eq!(

3622

3

                        kv.get_key("i64").into_f64()?.unwrap(),

3623

3

                        9_007_199_254_740_992_f64

3624

);

3625

3

                    kv.set_numeric_key("i64", -(2_i64.pow(f64::MANTISSA_DIGITS)))

3626

3

                        .execute()?;

3627

3

                    $crate::assert_f64_eq!(

3628

3

                        kv.get_key("i64").into_f64()?.unwrap(),

3629

3

                        -9_007_199_254_740_992_f64

3630

);

3631

3632

3

                    kv.set_numeric_key("i64", (2_i64.pow(f64::MANTISSA_DIGITS) + 1))

3633

3

                        .execute()?;

3634

3

                    assert!(kv.get_key("i64").into_f64().is_err());

3635

3

                    $crate::assert_f64_eq!(

3636

3

                        kv.get_key("i64").into_f64_lossy()?.unwrap(),

3637

3

                        9_007_199_254_740_993_f64

3638

);

3639

3

                    kv.set_numeric_key("i64", -(2_i64.pow(f64::MANTISSA_DIGITS) + 1))

3640

3

                        .execute()?;

3641

3

                    assert!(kv.get_key("i64").into_f64().is_err());

3642

3

                    $crate::assert_f64_eq!(

3643

3

                        kv.get_key("i64").into_f64_lossy()?.unwrap(),

3644

3

                        -9_007_199_254_740_993_f64

3645

);

3646

3647

                    // For i64 -> u64, the only limit is sign.

3648

3

                    kv.set_numeric_key("i64", -1_i64).execute()?;

3649

3

                    assert!(kv.get_key("i64").into_u64().is_err());

3650

3

                    assert_eq!(kv.get_key("i64").into_u64_lossy(true)?.unwrap(), 0_u64);

3651

3

                    assert_eq!(kv.get_key("i64").into_u64_lossy(false)?.unwrap(), u64::MAX);

3652

3653

                    // For f64 -> i64, the limit is fractional numbers. Saturating isn't tested in this conversion path.

3654

3

                    kv.set_numeric_key("f64", 1.1_f64).execute()?;

3655

3

                    assert!(kv.get_key("f64").into_i64().is_err());

3656

3

                    assert_eq!(kv.get_key("f64").into_i64_lossy(false)?.unwrap(), 1_i64);

3657

3

                    kv.set_numeric_key("f64", -1.1_f64).execute()?;

3658

3

                    assert!(kv.get_key("f64").into_i64().is_err());

3659

3

                    assert_eq!(kv.get_key("f64").into_i64_lossy(false)?.unwrap(), -1_i64);

3660

3661

                    // For f64 -> u64, the limit is fractional numbers or negative numbers. Saturating isn't tested in this conversion path.

3662

3

                    kv.set_numeric_key("f64", 1.1_f64).execute()?;

3663

3

                    assert!(kv.get_key("f64").into_u64().is_err());

3664

3

                    assert_eq!(kv.get_key("f64").into_u64_lossy(false)?.unwrap(), 1_u64);

3665

3

                    kv.set_numeric_key("f64", -1.1_f64).execute()?;

3666

3

                    assert!(kv.get_key("f64").into_u64().is_err());

3667

3

                    assert_eq!(kv.get_key("f64").into_u64_lossy(false)?.unwrap(), 0_u64);

3668

3669

                    // For u64 -> i64, the limit is > i64::MAX

3670

3

                    kv.set_numeric_key("u64", i64::MAX as u64 + 1).execute()?;

3671

3

                    assert!(kv.get_key("u64").into_i64().is_err());

3672

3

                    assert_eq!(kv.get_key("u64").into_i64_lossy(true)?.unwrap(), i64::MAX);

3673

3

                    assert_eq!(kv.get_key("u64").into_i64_lossy(false)?.unwrap(), i64::MIN);

3674

3675

3676

                // Test that non-numeric keys won't be changed when attempting to incr/decr

3677

3

                kv.set_key("non-numeric", &String::from("test")).execute()?;

3678

3

                assert!(kv.increment_key_by("non-numeric", 1_i64).execute().is_err());

3679

3

                assert!(kv.decrement_key_by("non-numeric", 1_i64).execute().is_err());

3680

3

                assert_eq!(

3681

3

                    kv.get_key("non-numeric").into::<String>()?.unwrap(),

3682

3

                    String::from("test")

3683

);

3684

3685

                // Test that NaN cannot be stored

3686

3

                kv.set_numeric_key("f64", 0_f64).execute()?;

3687

3

                assert!(matches!(

3688

3

                    kv.set_numeric_key("f64", f64::NAN).execute(),

3689

                    Err(bonsaidb_core::Error::NotANumber)

3690

));

3691

                // Verify the value was unchanged.

3692

3

                $crate::assert_f64_eq!(kv.get_key("f64").into_f64()?.unwrap(), 0.);

3693

                // Try to increment by nan

3694

3

                assert!(matches!(

3695

3

                    kv.increment_key_by("f64", f64::NAN).execute(),

3696

                    Err(bonsaidb_core::Error::NotANumber)

3697

));

3698

3

                $crate::assert_f64_eq!(kv.get_key("f64").into_f64()?.unwrap(), 0.);

3699

3700

3

                harness.shutdown()?;

3701

3702

3

                Ok(())

3703

3

3704

3705

            #[test]

3706

3

            fn kv_expiration_tests() -> anyhow::Result<()> {

3707

                use std::time::Duration;

3708

3709

                use $crate::keyvalue::{KeyStatus, KeyValue};

3710

3711

3

                let harness = $harness::new($crate::test_util::HarnessTest::KvExpiration)?;

3712

3

                let db = harness.connect()?;

3713

3714

3

                loop {

3715

3

                    let kv = db.with_key_namespace("expiration");

3716

3

3717

3

                    kv.delete_key("a")?;

3718

3

                    kv.delete_key("b")?;

3719

3720

                    // Test that the expiration is updated for key a, but not for key b.

3721

3

                    let timing = $crate::test_util::TimingTest::new(Duration::from_millis(500));

3722

3

                    let r1 = kv

3723

3

                        .set_key("a", &0_u32)

3724

3

                        .expire_in(Duration::from_secs(2))

3725

3

                        .execute()

3726

3

                        .unwrap();

3727

3

                    let r2 = kv

3728

3

                        .set_key("b", &0_u32)

3729

3

                        .expire_in(Duration::from_secs(2))

3730

3

                        .execute()

3731

3

                        .unwrap();

3732

3

                    assert_eq!(r1, KeyStatus::Inserted);

3733

3

                    assert_eq!(r2, KeyStatus::Inserted);

3734

3

                    let r1 = kv

3735

3

                        .set_key("a", &1_u32)

3736

3

                        .expire_in(Duration::from_secs(4))

3737

3

                        .execute()

3738

3

                        .unwrap();

3739

3

                    let r2 = kv

3740

3

                        .set_key("b", &1_u32)

3741

3

                        .expire_in(Duration::from_secs(100))

3742

3

                        .keep_existing_expiration()

3743

3

                        .execute()

3744

3

                        .unwrap();

3745

3

3746

3

                    if timing.elapsed() > Duration::from_secs(1) {

3747

                        println!(

3748

                            "Restarting test {}. Took too long {:?}",

3749

                            line!(),

3750

                            timing.elapsed(),

3751

);

3752

                        continue;

3753

3

3754

3

3755

3

                    assert_eq!(r1, KeyStatus::Updated, "a wasn't an update");

3756

3

                    assert_eq!(r2, KeyStatus::Updated, "b wasn't an update");

3757

3758

3

                    let a = kv.get_key("a").into()?;

3759

3

                    assert_eq!(a, Some(1u32), "a shouldn't have expired yet");

3760

3761

                    // Before checking the value, make sure we haven't elapsed too

3762

                    // much time. If so, just restart the test.

3763

3

                    if !timing.wait_until(Duration::from_secs_f32(3.)) {

3764

                        println!(

3765

                            "Restarting test {}. Took too long {:?}",

3766

                            line!(),

3767

                            timing.elapsed()

3768

);

3769

                        continue;

3770

3

3771

3772

3

                    assert_eq!(kv.get_key("b").query()?, None, "b never expired");

3773

3774

3

                    timing.wait_until(Duration::from_secs_f32(5.));

3775

3

                    assert_eq!(kv.get_key("a").query()?, None, "a never expired");

3776

3

                    break;

3777

3

3778

3

                harness.shutdown()?;

3779

3780

3

                Ok(())

3781

3

3782

3783

            #[test]

3784

3

            fn delete_expire_tests() -> anyhow::Result<()> {

3785

                use std::time::Duration;

3786

3787

                use $crate::keyvalue::{KeyStatus, KeyValue};

3788

3789

3

                let harness = $harness::new($crate::test_util::HarnessTest::KvDeleteExpire)?;

3790

3

                let db = harness.connect()?;

3791

3792

3

                loop {

3793

3

                    let kv = db.with_key_namespace("delete_expire");

3794

3

3795

3

                    kv.delete_key("a")?;

3796

3797

3

                    let timing = $crate::test_util::TimingTest::new(Duration::from_millis(100));

3798

3

3799

3

                    // Create a key with an expiration. Delete the key. Set a new

3800

3

                    // value at that key with no expiration. Ensure it doesn't

3801

3

                    // expire.

3802

3

                    kv.set_key("a", &0_u32)

3803

3

                        .expire_in(Duration::from_secs(2))

3804

3

                        .execute()?;

3805

3

                    kv.delete_key("a")?;

3806

3

                    kv.set_key("a", &1_u32).execute()?;

3807

3

                    if timing.elapsed() > Duration::from_secs(1) {

3808

                        println!(

3809

                            "Restarting test {}. Took too long {:?}",

3810

                            line!(),

3811

                            timing.elapsed(),

3812

);

3813

                        continue;

3814

3

3815

3

                    if !timing.wait_until(Duration::from_secs_f32(2.5)) {

3816

                        println!(

3817

                            "Restarting test {}. Took too long {:?}",

3818

                            line!(),

3819

                            timing.elapsed()

3820

);

3821

                        continue;

3822

3

3823

3824

3

                    assert_eq!(kv.get_key("a").into()?, Some(1u32));

3825

3826

3

                    break;

3827

3

3828

3

                harness.shutdown()?;

3829

3830

3

                Ok(())

3831

3

3832

3833

            #[test]

3834

            // This test can fail when the machine its running on is under high load or

3835

            // constrained resources. We need a command that persists (and waits until

3836

            // persist) to make this test fully deterministic.

3837

3

            fn kv_transaction_tests() -> anyhow::Result<()> {

3838

                use std::time::Duration;

3839

3840

                use $crate::connection::Connection;

3841

                use $crate::keyvalue::{KeyStatus, KeyValue};

3842

                // loop {

3843

3

                let harness = $harness::new($crate::test_util::HarnessTest::KvTransactions)?;

3844

3

                let db = harness.connect()?;

3845

                // Generate several transactions that we can validate. Persisting

3846

                // happens in the background, so we delay between each step to give

3847

                // it a moment.

3848

3

                db.set_key("expires", &0_u32)

3849

3

                    .expire_in(Duration::from_secs(1))

3850

3

                    .execute()?;

3851

3

                db.set_key("akey", &String::from("avalue")).execute()?;

3852

3

                db.set_numeric_key("nkey", 0_u64).execute()?;

3853

3

                std::thread::sleep(Duration::from_millis(500));

3854

3

                db.increment_key_by("nkey", 1_u64).execute()?;

3855

3

                std::thread::sleep(Duration::from_millis(500));

3856

3

                db.delete_key("nkey")?;

3857

3

                db.get_key("akey").and_delete().query()?;

3858

3

                std::thread::sleep(Duration::from_millis(500));

3859

3

                // Ensure this doesn't generate a transaction.

3860

3

                db.delete_key("nkey")?;

3861

3862

3

                std::thread::sleep(Duration::from_secs(1));

3863

3864

3

                let transactions = Connection::list_executed_transactions(&db, None, None)?;

3865

3

                let deleted_keys = transactions

3866

3

                    .iter()

3867

3

                    .filter_map(|tx| tx.changes.keys())

3868

3

                    .flatten()

3869

3

                    .filter(|changed_key| dbg!(changed_key).deleted)

3870

3

                    .count();

3871

3

                assert_eq!(deleted_keys, 3, "deleted keys wasn't 3");

3872

3

                let akey_changes = transactions

3873

3

                    .iter()

3874

3

                    .filter_map(|tx| tx.changes.keys())

3875

3

                    .flatten()

3876

3

                    .filter(|changed_key| changed_key.key == "akey")

3877

3

                    .count();

3878

3

                assert_eq!(akey_changes, 2, "akey changes wasn't 2");

3879

3

                let nkey_changes = transactions

3880

3

                    .iter()

3881

3

                    .filter_map(|tx| tx.changes.keys())

3882

3

                    .flatten()

3883

3

                    .filter(|changed_key| changed_key.key == "nkey")

3884

3

                    .count();

3885

3

                assert_eq!(nkey_changes, 3, "nkey changes wasn't 3");

3886

3887

3

                harness.shutdown()?;

3888

                // }

3889

3890

3

                Ok(())

3891

3

3892

3893

};

3894

3895

3896

pub struct TimingTest {

3897

    tolerance: Duration,

3898

    start: Instant,

3899

3900

3901

impl TimingTest {

3902

    #[must_use]

3903

760

    pub fn new(tolerance: Duration) -> Self {

3904

760

        Self {

3905

760

            tolerance,

3906

760

            start: Instant::now(),

3907

760

3908

760

3909

3910

    #[allow(clippy::must_use_candidate)]

3911

440

    pub fn wait_until(&self, absolute_duration: Duration) -> bool {

3912

440

        let target = self.start + absolute_duration;

3913

440

        let mut now = Instant::now();

3914

440

        if let Some(sleep_duration) = target.checked_duration_since(now) {

3915

440

            std::thread::sleep(sleep_duration);

3916

440

            now = Instant::now();

3917

440

3918

440

        let amount_past = now.checked_duration_since(target);

3919

440

        // Return false if we're beyond the tolerance given

3920

440

        amount_past.unwrap_or_default() < self.tolerance

3921

440

3922

3923

600

    pub async fn wait_until_async(&self, absolute_duration: Duration) -> bool {

3924

15

        let target = self.start + absolute_duration;

3925

15

        let mut now = Instant::now();

3926

15

        if now < target {

3927

15

            tokio::time::sleep_until(target.into()).await;

3928

15

            now = Instant::now();

3929

3930

15

        let amount_past = now.checked_duration_since(target);

3931

15

3932

15

        // Return false if we're beyond the tolerance given

3933

15

        amount_past.unwrap_or_default() < self.tolerance

3934

15

3935

3936

    #[must_use]

3937

1080

    pub fn elapsed(&self) -> Duration {

3938

1080

        Instant::now()

3939

1080

            .checked_duration_since(self.start)

3940

1080

            .unwrap_or_default()

3941

1080

3942

3943

3944

5

pub async fn basic_server_connection_tests<C: AsyncStorageConnection>(

3945

5

    server: C,

3946

5

    newdb_name: &str,

3947

5

) -> anyhow::Result<()> {

3948

5

    let schemas = server.list_available_schemas().await?;

3949

3950

5

    let basic_schema = schemas

3951

5

        .iter()

3952

7

        .find(|s| s.name == BasicSchema::schema_name())

3953

5

        .unwrap();

3954

5

    assert!(basic_schema

3955

5

        .collections()

3956

10

        .any(|c| c.name == Basic::collection_name()));

3957

5

    let basic_collection = basic_schema.collection(&Basic::collection_name()).unwrap();

3958

5

    assert!(basic_collection

3959

5

        .views()

3960

24

        .any(|v| v.name == BasicByParentId.view_name()));

3961

5

    let by_parent_id = basic_collection.view(&BasicByParentId.view_name()).unwrap();

3962

5

    assert_eq!(by_parent_id.policy, ViewUpdatePolicy::Lazy);

3963

3964

5

    assert!(schemas

3965

5

        .iter()

3966

11

        .any(|s| s.name == SchemaName::new("khonsulabs", "bonsaidb-admin")));

3967

3968

5

    let databases = server.list_databases().await?;

3969

23

    assert!(databases.iter().any(|db| db.name == "tests"));

3970

3971

5

    server

3972

5

        .create_database::<BasicSchema>(newdb_name, false)

3973

8

        .await?;

3974

5

    server.delete_database(newdb_name).await?;

3975

3976

    assert!(matches!(

3977

5

        server.delete_database(newdb_name).await,

3978

        Err(Error::DatabaseNotFound(_))

3979

));

3980

3981

    assert!(matches!(

3982

5

        server.create_database::<BasicSchema>("tests", false).await,

3983

        Err(Error::DatabaseNameAlreadyTaken(_))

3984

));

3985

3986

5

    assert!(server

3987

5

        .create_database::<BasicSchema>("tests", true)

3988

8

        .await

3989

5

        .is_ok());

3990

3991

    assert!(matches!(

3992

5

        server

3993

5

            .create_database::<BasicSchema>("|invalidname", false)

3994

5

            .await,

3995

        Err(Error::InvalidDatabaseName(_))

3996

));

3997

3998

    assert!(matches!(

3999

5

        server

4000

5

            .create_database::<UnassociatedCollection>(newdb_name, false)

4001

5

            .await,

4002

        Err(Error::SchemaNotRegistered(_))

4003

));

4004

4005

5

    Ok(())

4006

5

4007

4008

3

pub fn blocking_basic_server_connection_tests<C: StorageConnection>(

4009

3

    server: &C,

4010

3

    newdb_name: &str,

4011

3

) -> anyhow::Result<()> {

4012

3

    let schemas = server.list_available_schemas()?;

4013

3

    let basic_schema = schemas

4014

3

        .iter()

4015

4

        .find(|s| s.name == BasicSchema::schema_name())

4016

3

        .unwrap();

4017

3

    assert!(basic_schema

4018

3

        .collections()

4019

5

        .any(|c| c.name == Basic::collection_name()));

4020

3

    let basic_collection = basic_schema.collection(&Basic::collection_name()).unwrap();

4021

3

    assert!(basic_collection

4022

3

        .views()

4023

10

        .any(|v| v.name == BasicByParentId.view_name()));

4024

3

    let by_parent_id = basic_collection.view(&BasicByParentId.view_name()).unwrap();

4025

3

    assert_eq!(by_parent_id.policy, ViewUpdatePolicy::Lazy);

4026

4027

3

    assert!(schemas

4028

3

        .iter()

4029

6

        .any(|s| s.name == SchemaName::new("khonsulabs", "bonsaidb-admin")));

4030

4031

3

    let databases = server.list_databases()?;

4032

8

    assert!(databases.iter().any(|db| db.name == "tests"));

4033

4034

3

    server.create_database::<BasicSchema>(newdb_name, false)?;

4035

3

    server.delete_database(newdb_name)?;

4036

4037

3

    assert!(matches!(

4038

3

        server.delete_database(newdb_name),

4039

        Err(Error::DatabaseNotFound(_))

4040

));

4041

4042

3

    assert!(matches!(

4043

3

        server.create_database::<BasicSchema>("tests", false),

4044

        Err(Error::DatabaseNameAlreadyTaken(_))

4045

));

4046

4047

3

    assert!(server.create_database::<BasicSchema>("tests", true).is_ok());

4048

4049

3

    assert!(matches!(

4050

3

        server.create_database::<BasicSchema>("|invalidname", false),

4051

        Err(Error::InvalidDatabaseName(_))

4052

));

4053

4054

3

    assert!(matches!(

4055

3

        server.create_database::<UnassociatedCollection>(newdb_name, false),

4056

        Err(Error::SchemaNotRegistered(_))

4057

));

4058

4059

3

    Ok(())

4060

3