commit e2b8ec089f0022a3cb7daa46ca8834ada2e3c91a
parent 603384ec51393809142814ab3581aa6379f78810
Author: triesap <tyson@radroots.org>
Date: Fri, 6 Mar 2026 18:49:21 +0000
tests: expand replica-db model error-path coverage matrix
- extend error path tests across farm, plot, tag, member, event state, and trade product models
- add missing-id update and delete assertions to cover not-found lookup branches
- force missing-table failures for create, find, update, and delete entrypoints across core model groups
- raise replica-db region coverage while preserving clean crate test execution
Diffstat:
1 file changed, 619 insertions(+), 0 deletions(-)
diff --git a/crates/replica-db/tests/error_paths.rs b/crates/replica-db/tests/error_paths.rs
@@ -1,12 +1,37 @@
use radroots_replica_db::ReplicaSql;
+use radroots_replica_db_schema::farm::{
+ IFarmCreate, IFarmDelete, IFarmFindMany, IFarmFindOne, IFarmUpdate,
+};
+use radroots_replica_db_schema::farm_gcs_location::{
+ IFarmGcsLocationCreate, IFarmGcsLocationDelete, IFarmGcsLocationFindMany,
+ IFarmGcsLocationFindOne, IFarmGcsLocationUpdate,
+};
+use radroots_replica_db_schema::farm_member::{
+ IFarmMemberCreate, IFarmMemberDelete, IFarmMemberFindMany, IFarmMemberFindOne,
+ IFarmMemberUpdate,
+};
+use radroots_replica_db_schema::farm_member_claim::{
+ IFarmMemberClaimCreate, IFarmMemberClaimDelete, IFarmMemberClaimFindMany,
+ IFarmMemberClaimFindOne, IFarmMemberClaimUpdate,
+};
+use radroots_replica_db_schema::farm_tag::{
+ IFarmTagCreate, IFarmTagDelete, IFarmTagFindMany, IFarmTagFindOne, IFarmTagUpdate,
+};
use radroots_replica_db_schema::gcs_location::{
IGcsLocationCreate, IGcsLocationDelete, IGcsLocationFindMany, IGcsLocationFindOne,
IGcsLocationUpdate,
};
+use radroots_replica_db_schema::log_error::{
+ ILogErrorCreate, ILogErrorDelete, ILogErrorFindMany, ILogErrorFindOne, ILogErrorUpdate,
+};
use radroots_replica_db_schema::media_image::{
IMediaImageCreate, IMediaImageDelete, IMediaImageFindMany, IMediaImageFindOne,
IMediaImageUpdate,
};
+use radroots_replica_db_schema::nostr_event_state::{
+ INostrEventStateCreate, INostrEventStateDelete, INostrEventStateFindMany,
+ INostrEventStateFindOne, INostrEventStateUpdate,
+};
use radroots_replica_db_schema::nostr_profile::{
INostrProfileCreate, INostrProfileDelete, INostrProfileFindMany, INostrProfileFindOne,
INostrProfileUpdate,
@@ -15,6 +40,20 @@ use radroots_replica_db_schema::nostr_relay::{
INostrRelayCreate, INostrRelayDelete, INostrRelayFindMany, INostrRelayFindOne,
INostrRelayUpdate,
};
+use radroots_replica_db_schema::plot::{
+ IPlotCreate, IPlotDelete, IPlotFindMany, IPlotFindOne, IPlotUpdate,
+};
+use radroots_replica_db_schema::plot_gcs_location::{
+ IPlotGcsLocationCreate, IPlotGcsLocationDelete, IPlotGcsLocationFindMany,
+ IPlotGcsLocationFindOne, IPlotGcsLocationUpdate,
+};
+use radroots_replica_db_schema::plot_tag::{
+ IPlotTagCreate, IPlotTagDelete, IPlotTagFindMany, IPlotTagFindOne, IPlotTagUpdate,
+};
+use radroots_replica_db_schema::trade_product::{
+ ITradeProductCreate, ITradeProductDelete, ITradeProductFindMany, ITradeProductFindOne,
+ ITradeProductUpdate,
+};
use radroots_sql_core::{SqlError, SqlExecutor, SqliteExecutor};
use radroots_types::types::IError;
use serde::de::DeserializeOwned;
@@ -321,3 +360,583 @@ fn nostr_relay_error_paths_cover_regions() {
}));
assert_invalid_query(db.nostr_relay_delete(&delete_rel));
}
+
+#[test]
+fn farm_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: IFarmUpdate = parse_json(json!({
+ "on": { "d_tag": "missing-farm" },
+ "fields": { "name": "farm x" }
+ }));
+ assert_not_found(db.farm_update(&update_missing));
+
+ let update_missing_id: IFarmUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "name": "farm y" }
+ }));
+ assert_not_found(db.farm_update(&update_missing_id));
+
+ let delete_missing_on: IFarmDelete = parse_json(json!({
+ "on": { "d_tag": "missing-farm" }
+ }));
+ assert_not_found(db.farm_delete(&delete_missing_on));
+
+ drop_table(&db, "farm");
+
+ let create_opts: IFarmCreate = parse_json(json!({
+ "d_tag": "farm-a",
+ "pubkey": hex64('a'),
+ "name": "farm a"
+ }));
+ assert_invalid_query(db.farm_create(&create_opts));
+
+ let find_many_filter: IFarmFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_find_many(&find_many_filter));
+
+ let find_one_on: IFarmFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_find_one(&find_one_on));
+
+ let update_id: IFarmUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "name": "farm z" }
+ }));
+ assert_invalid_query(db.farm_update(&update_id));
+
+ let delete_id: IFarmDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_delete(&delete_id));
+}
+
+#[test]
+fn plot_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: IPlotUpdate = parse_json(json!({
+ "on": { "d_tag": "missing-plot" },
+ "fields": { "name": "plot x" }
+ }));
+ assert_not_found(db.plot_update(&update_missing));
+
+ let update_missing_id: IPlotUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "name": "plot y" }
+ }));
+ assert_not_found(db.plot_update(&update_missing_id));
+
+ let delete_missing_on: IPlotDelete = parse_json(json!({
+ "on": { "d_tag": "missing-plot" }
+ }));
+ assert_not_found(db.plot_delete(&delete_missing_on));
+
+ drop_table(&db, "plot");
+
+ let create_opts: IPlotCreate = parse_json(json!({
+ "d_tag": "plot-a",
+ "farm_id": "farm-1",
+ "name": "plot a"
+ }));
+ assert_invalid_query(db.plot_create(&create_opts));
+
+ let find_many_filter: IPlotFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.plot_find_many(&find_many_filter));
+
+ let find_one_on: IPlotFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.plot_find_one(&find_one_on));
+
+ let update_id: IPlotUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "name": "plot z" }
+ }));
+ assert_invalid_query(db.plot_update(&update_id));
+
+ let delete_id: IPlotDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.plot_delete(&delete_id));
+}
+
+#[test]
+fn farm_gcs_location_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: IFarmGcsLocationUpdate = parse_json(json!({
+ "on": { "farm_id": "farm-1" },
+ "fields": { "role": "x" }
+ }));
+ assert_not_found(db.farm_gcs_location_update(&update_missing));
+
+ let update_missing_id: IFarmGcsLocationUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "role": "y" }
+ }));
+ assert_not_found(db.farm_gcs_location_update(&update_missing_id));
+
+ let delete_missing_on: IFarmGcsLocationDelete = parse_json(json!({
+ "on": { "farm_id": "farm-1" }
+ }));
+ assert_not_found(db.farm_gcs_location_delete(&delete_missing_on));
+
+ drop_table(&db, "farm_gcs_location");
+
+ let create_opts: IFarmGcsLocationCreate = parse_json(json!({
+ "farm_id": "farm-1",
+ "gcs_location_id": "gcs-1",
+ "role": "primary"
+ }));
+ assert_invalid_query(db.farm_gcs_location_create(&create_opts));
+
+ let find_many_filter: IFarmGcsLocationFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_gcs_location_find_many(&find_many_filter));
+
+ let find_one_on: IFarmGcsLocationFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_gcs_location_find_one(&find_one_on));
+
+ let update_id: IFarmGcsLocationUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "role": "z" }
+ }));
+ assert_invalid_query(db.farm_gcs_location_update(&update_id));
+
+ let delete_id: IFarmGcsLocationDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_gcs_location_delete(&delete_id));
+}
+
+#[test]
+fn plot_gcs_location_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: IPlotGcsLocationUpdate = parse_json(json!({
+ "on": { "plot_id": "plot-1" },
+ "fields": { "role": "x" }
+ }));
+ assert_not_found(db.plot_gcs_location_update(&update_missing));
+
+ let update_missing_id: IPlotGcsLocationUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "role": "y" }
+ }));
+ assert_not_found(db.plot_gcs_location_update(&update_missing_id));
+
+ let delete_missing_on: IPlotGcsLocationDelete = parse_json(json!({
+ "on": { "plot_id": "plot-1" }
+ }));
+ assert_not_found(db.plot_gcs_location_delete(&delete_missing_on));
+
+ drop_table(&db, "plot_gcs_location");
+
+ let create_opts: IPlotGcsLocationCreate = parse_json(json!({
+ "plot_id": "plot-1",
+ "gcs_location_id": "gcs-1",
+ "role": "primary"
+ }));
+ assert_invalid_query(db.plot_gcs_location_create(&create_opts));
+
+ let find_many_filter: IPlotGcsLocationFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.plot_gcs_location_find_many(&find_many_filter));
+
+ let find_one_on: IPlotGcsLocationFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.plot_gcs_location_find_one(&find_one_on));
+
+ let update_id: IPlotGcsLocationUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "role": "z" }
+ }));
+ assert_invalid_query(db.plot_gcs_location_update(&update_id));
+
+ let delete_id: IPlotGcsLocationDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.plot_gcs_location_delete(&delete_id));
+}
+
+#[test]
+fn farm_tag_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: IFarmTagUpdate = parse_json(json!({
+ "on": { "farm_id": "farm-1" },
+ "fields": { "tag": "x" }
+ }));
+ assert_not_found(db.farm_tag_update(&update_missing));
+
+ let update_missing_id: IFarmTagUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "tag": "y" }
+ }));
+ assert_not_found(db.farm_tag_update(&update_missing_id));
+
+ let delete_missing_on: IFarmTagDelete = parse_json(json!({
+ "on": { "farm_id": "farm-1" }
+ }));
+ assert_not_found(db.farm_tag_delete(&delete_missing_on));
+
+ drop_table(&db, "farm_tag");
+
+ let create_opts: IFarmTagCreate = parse_json(json!({
+ "farm_id": "farm-1",
+ "tag": "organic"
+ }));
+ assert_invalid_query(db.farm_tag_create(&create_opts));
+
+ let find_many_filter: IFarmTagFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_tag_find_many(&find_many_filter));
+
+ let find_one_on: IFarmTagFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_tag_find_one(&find_one_on));
+
+ let update_id: IFarmTagUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "tag": "z" }
+ }));
+ assert_invalid_query(db.farm_tag_update(&update_id));
+
+ let delete_id: IFarmTagDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_tag_delete(&delete_id));
+}
+
+#[test]
+fn plot_tag_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: IPlotTagUpdate = parse_json(json!({
+ "on": { "plot_id": "plot-1" },
+ "fields": { "tag": "x" }
+ }));
+ assert_not_found(db.plot_tag_update(&update_missing));
+
+ let update_missing_id: IPlotTagUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "tag": "y" }
+ }));
+ assert_not_found(db.plot_tag_update(&update_missing_id));
+
+ let delete_missing_on: IPlotTagDelete = parse_json(json!({
+ "on": { "plot_id": "plot-1" }
+ }));
+ assert_not_found(db.plot_tag_delete(&delete_missing_on));
+
+ drop_table(&db, "plot_tag");
+
+ let create_opts: IPlotTagCreate = parse_json(json!({
+ "plot_id": "plot-1",
+ "tag": "north"
+ }));
+ assert_invalid_query(db.plot_tag_create(&create_opts));
+
+ let find_many_filter: IPlotTagFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.plot_tag_find_many(&find_many_filter));
+
+ let find_one_on: IPlotTagFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.plot_tag_find_one(&find_one_on));
+
+ let update_id: IPlotTagUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "tag": "z" }
+ }));
+ assert_invalid_query(db.plot_tag_update(&update_id));
+
+ let delete_id: IPlotTagDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.plot_tag_delete(&delete_id));
+}
+
+#[test]
+fn farm_member_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: IFarmMemberUpdate = parse_json(json!({
+ "on": { "member_pubkey": hex64('a') },
+ "fields": { "role": "x" }
+ }));
+ assert_not_found(db.farm_member_update(&update_missing));
+
+ let update_missing_id: IFarmMemberUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "role": "y" }
+ }));
+ assert_not_found(db.farm_member_update(&update_missing_id));
+
+ let delete_missing_on: IFarmMemberDelete = parse_json(json!({
+ "on": { "member_pubkey": hex64('a') }
+ }));
+ assert_not_found(db.farm_member_delete(&delete_missing_on));
+
+ drop_table(&db, "farm_member");
+
+ let create_opts: IFarmMemberCreate = parse_json(json!({
+ "farm_id": "farm-1",
+ "member_pubkey": hex64('a'),
+ "role": "owner"
+ }));
+ assert_invalid_query(db.farm_member_create(&create_opts));
+
+ let find_many_filter: IFarmMemberFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_member_find_many(&find_many_filter));
+
+ let find_one_on: IFarmMemberFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_member_find_one(&find_one_on));
+
+ let update_id: IFarmMemberUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "role": "z" }
+ }));
+ assert_invalid_query(db.farm_member_update(&update_id));
+
+ let delete_id: IFarmMemberDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_member_delete(&delete_id));
+}
+
+#[test]
+fn farm_member_claim_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: IFarmMemberClaimUpdate = parse_json(json!({
+ "on": { "member_pubkey": hex64('a') },
+ "fields": { "farm_pubkey": hex64('b') }
+ }));
+ assert_not_found(db.farm_member_claim_update(&update_missing));
+
+ let update_missing_id: IFarmMemberClaimUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "farm_pubkey": hex64('c') }
+ }));
+ assert_not_found(db.farm_member_claim_update(&update_missing_id));
+
+ let delete_missing_on: IFarmMemberClaimDelete = parse_json(json!({
+ "on": { "member_pubkey": hex64('a') }
+ }));
+ assert_not_found(db.farm_member_claim_delete(&delete_missing_on));
+
+ drop_table(&db, "farm_member_claim");
+
+ let create_opts: IFarmMemberClaimCreate = parse_json(json!({
+ "member_pubkey": hex64('a'),
+ "farm_pubkey": hex64('b')
+ }));
+ assert_invalid_query(db.farm_member_claim_create(&create_opts));
+
+ let find_many_filter: IFarmMemberClaimFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_member_claim_find_many(&find_many_filter));
+
+ let find_one_on: IFarmMemberClaimFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_member_claim_find_one(&find_one_on));
+
+ let update_id: IFarmMemberClaimUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "farm_pubkey": hex64('c') }
+ }));
+ assert_invalid_query(db.farm_member_claim_update(&update_id));
+
+ let delete_id: IFarmMemberClaimDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.farm_member_claim_delete(&delete_id));
+}
+
+#[test]
+fn log_error_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: ILogErrorUpdate = parse_json(json!({
+ "on": { "nostr_pubkey": hex64('a') },
+ "fields": { "message": "x" }
+ }));
+ assert_not_found(db.log_error_update(&update_missing));
+
+ let update_missing_id: ILogErrorUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "message": "y" }
+ }));
+ assert_not_found(db.log_error_update(&update_missing_id));
+
+ let delete_missing_on: ILogErrorDelete = parse_json(json!({
+ "on": { "nostr_pubkey": hex64('a') }
+ }));
+ assert_not_found(db.log_error_delete(&delete_missing_on));
+
+ drop_table(&db, "log_error");
+
+ let create_opts: ILogErrorCreate = parse_json(json!({
+ "error": "panic",
+ "message": "boom",
+ "app_system": "studio",
+ "app_version": "1.0.0",
+ "nostr_pubkey": hex64('a')
+ }));
+ assert_invalid_query(db.log_error_create(&create_opts));
+
+ let find_many_filter: ILogErrorFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.log_error_find_many(&find_many_filter));
+
+ let find_one_on: ILogErrorFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.log_error_find_one(&find_one_on));
+
+ let update_id: ILogErrorUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "message": "z" }
+ }));
+ assert_invalid_query(db.log_error_update(&update_id));
+
+ let delete_id: ILogErrorDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.log_error_delete(&delete_id));
+}
+
+#[test]
+fn nostr_event_state_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: INostrEventStateUpdate = parse_json(json!({
+ "on": { "key": "state-a" },
+ "fields": { "content_hash": "hash-x" }
+ }));
+ assert_not_found(db.nostr_event_state_update(&update_missing));
+
+ let update_missing_id: INostrEventStateUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "content_hash": "hash-y" }
+ }));
+ assert_not_found(db.nostr_event_state_update(&update_missing_id));
+
+ let delete_missing_on: INostrEventStateDelete = parse_json(json!({
+ "on": { "key": "state-a" }
+ }));
+ assert_not_found(db.nostr_event_state_delete(&delete_missing_on));
+
+ drop_table(&db, "nostr_event_state");
+
+ let create_opts: INostrEventStateCreate = parse_json(json!({
+ "key": "state-a",
+ "kind": 30023,
+ "pubkey": hex64('a'),
+ "d_tag": "listing-a",
+ "last_event_id": hex64('b'),
+ "last_created_at": 1,
+ "content_hash": "hash-a"
+ }));
+ assert_invalid_query(db.nostr_event_state_create(&create_opts));
+
+ let find_many_filter: INostrEventStateFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.nostr_event_state_find_many(&find_many_filter));
+
+ let find_one_on: INostrEventStateFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.nostr_event_state_find_one(&find_one_on));
+
+ let update_id: INostrEventStateUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "content_hash": "hash-z" }
+ }));
+ assert_invalid_query(db.nostr_event_state_update(&update_id));
+
+ let delete_id: INostrEventStateDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.nostr_event_state_delete(&delete_id));
+}
+
+#[test]
+fn trade_product_error_paths_cover_regions() {
+ let db = open_db();
+
+ let update_missing: ITradeProductUpdate = parse_json(json!({
+ "on": { "id": "missing-id" },
+ "fields": { "title": "x" }
+ }));
+ assert_not_found(db.trade_product_update(&update_missing));
+
+ let delete_missing_on: ITradeProductDelete = parse_json(json!({
+ "on": { "id": "missing-id" }
+ }));
+ assert_not_found(db.trade_product_delete(&delete_missing_on));
+
+ drop_table(&db, "trade_product");
+
+ let create_opts: ITradeProductCreate = parse_json(json!({
+ "key": "product-a",
+ "category": "coffee",
+ "title": "coffee a",
+ "summary": "summary",
+ "process": "washed",
+ "lot": "lot-a",
+ "profile": "floral",
+ "year": 2024,
+ "qty_amt": 100,
+ "qty_unit": "kg",
+ "price_amt": 7.5,
+ "price_currency": "USD",
+ "price_qty_amt": 1,
+ "price_qty_unit": "kg"
+ }));
+ assert_invalid_query(db.trade_product_create(&create_opts));
+
+ let find_many_filter: ITradeProductFindMany = parse_json(json!({
+ "filter": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.trade_product_find_many(&find_many_filter));
+
+ let find_one_on: ITradeProductFindOne = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.trade_product_find_one(&find_one_on));
+
+ let update_id: ITradeProductUpdate = parse_json(json!({
+ "on": { "id": "id-1" },
+ "fields": { "title": "z" }
+ }));
+ assert_invalid_query(db.trade_product_update(&update_id));
+
+ let delete_id: ITradeProductDelete = parse_json(json!({
+ "on": { "id": "id-1" }
+ }));
+ assert_invalid_query(db.trade_product_delete(&delete_id));
+}
