Compare commits
No commits in common. "master" and "inventory-fix-aggregate-id" have entirely different histories.
master
...
inventory-
67 changed files with 1170 additions and 2509 deletions
|
|
@ -0,0 +1,27 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_billing_line_item_query\n SET\n version = $1,\n product_name = $2,\n product_id = $3,\n line_item_id = $4,\n quantity_minor_unit = $5,\n quantity_minor_number = $6,\n quantity_major_unit = $7,\n quantity_major_number = $8,\n created_time = $9,\n bill_id = $10,\n price_per_unit_minor = $11 ,\n price_per_unit_major = $12,\n price_per_unit_currency = $13,\n deleted = $14;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
"Left": [
|
||||
"Int8",
|
||||
"Text",
|
||||
"Uuid",
|
||||
"Uuid",
|
||||
"Text",
|
||||
"Int4",
|
||||
"Text",
|
||||
"Int4",
|
||||
"Timestamptz",
|
||||
"Uuid",
|
||||
"Int4",
|
||||
"Int4",
|
||||
"Text",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "0268f0c43abe34a3147f0a43f0e11bf302a3750ecadf28b1d6af62da62934f87"
|
||||
}
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_billing_store_query\n SET\n version = $1,\n name = $2,\n address = $3,\n owner = $4,\n deleted = $5;",
|
||||
"query": "UPDATE\n cqrs_billing_store_query\n SET\n version = $1,\n name = $2,\n address = $3,\n store_id = $4,\n owner = $5,\n deleted = $6;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
|
|
@ -9,10 +9,11 @@
|
|||
"Text",
|
||||
"Text",
|
||||
"Uuid",
|
||||
"Uuid",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "d7decc8f70fc4f12d7a1db5009d2190bb9746000067d53990eb7cd646ff5d252"
|
||||
"hash": "3811531518316435c32223582f9de6bdfefc19839129577407a1e4071f5c49f6"
|
||||
}
|
||||
|
|
@ -1,17 +1,18 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_ordering_kot_query\n SET\n version = $1,\n order_id = $2,\n created_time = $3,\n deleted = $4;",
|
||||
"query": "UPDATE\n cqrs_ordering_kot_query\n SET\n version = $1,\n order_id = $2,\n kot_id = $3,\n created_time = $4,\n deleted = $5;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
"Left": [
|
||||
"Int8",
|
||||
"Uuid",
|
||||
"Uuid",
|
||||
"Timestamptz",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "97c136fd927b9a153a6093da6594e5fc2837b3943b8bbcbade97920a99019c86"
|
||||
"hash": "4b7100e5c7442066dbb4ea7c9733e038af635766f0be61a86ca7084b34a2109d"
|
||||
}
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_billing_line_item_query\n SET\n version = $1,\n product_name = $2,\n product_id = $3,\n quantity_minor_unit = $4,\n quantity_minor_number = $5,\n quantity_major_unit = $6,\n quantity_major_number = $7,\n created_time = $8,\n bill_id = $9,\n price_per_unit_minor = $10 ,\n price_per_unit_major = $11,\n price_per_unit_currency = $12,\n deleted = $13;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
"Left": [
|
||||
"Int8",
|
||||
"Text",
|
||||
"Uuid",
|
||||
"Text",
|
||||
"Int4",
|
||||
"Text",
|
||||
"Int4",
|
||||
"Timestamptz",
|
||||
"Uuid",
|
||||
"Int4",
|
||||
"Int4",
|
||||
"Text",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "995cca627c711a87b30723c6ceefd3fcdd1fc63bdcd95f8a974823089652aa51"
|
||||
}
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "INSERT INTO cqrs_ordering_order_query (\n version,\n customer_name,\n order_id,\n created_time,\n store_id,\n deleted\n\n ) VALUES (\n $1, $2, $3, $4, $5, $6\n );",
|
||||
"query": "INSERT INTO cqrs_ordering_order_query (\n version,\n customer_name,\n order_id,\n created_time,\n deleted\n\n ) VALUES (\n $1, $2, $3, $4, $5\n );",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
|
|
@ -9,11 +9,10 @@
|
|||
"Text",
|
||||
"Uuid",
|
||||
"Timestamptz",
|
||||
"Uuid",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "7e2e91418e136fc5091b27c5f61158cca61e4853bee64e5afc44679e685cd744"
|
||||
"hash": "a342003149f2991ef0280d008f18e664c96299edfd9a11d08487e4db10a10e8b"
|
||||
}
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_billing_bill_query\n SET\n version = $1,\n\n created_time = $2,\n store_id = $3,\n token_number = $4,\n total_price_major = $5,\n total_price_minor = $6,\n total_price_currency = $7,\n deleted = $8;",
|
||||
"query": "UPDATE\n cqrs_billing_bill_query\n SET\n version = $1,\n\n created_time = $2,\n store_id = $3,\n bill_id = $4,\n token_number = $5,\n total_price_major = $6,\n total_price_minor = $7,\n total_price_currency = $8,\n\n deleted = $9;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
|
|
@ -8,6 +8,7 @@
|
|||
"Int8",
|
||||
"Timestamptz",
|
||||
"Uuid",
|
||||
"Uuid",
|
||||
"Int4",
|
||||
"Int4",
|
||||
"Int4",
|
||||
|
|
@ -17,5 +18,5 @@
|
|||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "c30f49bb293ca6e184c5110bdfe1108b23bdf71dd904bdd5287155161138565d"
|
||||
"hash": "b335fc519289a42c707855b620a35433d3f8bd1e798772c05fc156494c036ef5"
|
||||
}
|
||||
|
|
@ -1,18 +1,18 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_ordering_order_query\n SET\n version = $1,\n customer_name = $2,\n created_time = $3,\n store_id= $4,\n deleted = $5;",
|
||||
"query": "UPDATE\n cqrs_ordering_order_query\n SET\n version = $1,\n customer_name = $2,\n order_id = $3,\n created_time = $4,\n deleted = $5;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
"Left": [
|
||||
"Int8",
|
||||
"Text",
|
||||
"Timestamptz",
|
||||
"Uuid",
|
||||
"Timestamptz",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "876ca2c177175439a1604a2d5aeec785e41473116ceda238a8089bcb33588e3d"
|
||||
"hash": "bc7d17aab113d0519c53e5f612116a6e72bb0007a298cdba17f45f4b8bed5f56"
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_ordering_line_item_query\n SET\n version = $1,\n product_name = $2,\n product_id = $3,\n line_item_id = $4,\n quantity_minor_unit = $5,\n quantity_minor_number = $6,\n quantity_major_unit = $7,\n quantity_major_number = $8,\n created_time = $9,\n kot_id = $10,\n deleted = $11;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
"Left": [
|
||||
"Int8",
|
||||
"Text",
|
||||
"Uuid",
|
||||
"Uuid",
|
||||
"Text",
|
||||
"Int4",
|
||||
"Text",
|
||||
"Int4",
|
||||
"Timestamptz",
|
||||
"Uuid",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "c348d55dd91acb0d4697c433f61866b288fec93971bf9ab41faec21680e50f71"
|
||||
}
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_ordering_product_query\n SET\n version = $1,\n name = $2,\n description = $3,\n image = $4,\n category_id = $5,\n price_major = $6,\n price_minor = $7,\n price_currency = $8,\n sku_able = $9,\n quantity_minor_unit = $10,\n quantity_minor_number = $11,\n quantity_major_unit = $12,\n quantity_major_number = $13,\n deleted = $14;",
|
||||
"query": "UPDATE\n cqrs_ordering_product_query\n SET\n version = $1,\n name = $2,\n description = $3,\n image = $4,\n product_id = $5,\n category_id = $6,\n price_major = $7,\n price_minor = $8,\n price_currency = $9,\n sku_able = $10,\n quantity_minor_unit = $11,\n quantity_minor_number = $12,\n quantity_major_unit = $13,\n quantity_major_number = $14,\n deleted = $15;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
|
|
@ -10,6 +10,7 @@
|
|||
"Text",
|
||||
"Text",
|
||||
"Uuid",
|
||||
"Uuid",
|
||||
"Int4",
|
||||
"Int4",
|
||||
"Text",
|
||||
|
|
@ -23,5 +24,5 @@
|
|||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "a3fa1c6271b85d23d70116363f19144190120c13752364bc3b78a92a08bd9157"
|
||||
"hash": "c3a3348990d0fea3225fd2be2ef883ca1649e21fd28c1a35a0ffffce6035fd75"
|
||||
}
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_ordering_store_query\n SET\n version = $1,\n name = $2,\n address = $3,\n owner = $4,\n deleted = $5;",
|
||||
"query": "UPDATE\n cqrs_ordering_store_query\n SET\n version = $1,\n name = $2,\n address = $3,\n store_id = $4,\n owner = $5,\n deleted = $6;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
|
|
@ -9,10 +9,11 @@
|
|||
"Text",
|
||||
"Text",
|
||||
"Uuid",
|
||||
"Uuid",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "8a7958c4f8419e1fd95b2d0c75a3bab76f5962f37e58c7dee4e5f9341dca8c0e"
|
||||
"hash": "d0580ff6dc77150cb00186302f20460dc3be59be1f8f5588bdc3d0f4489eb613"
|
||||
}
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_ordering_category_query\n SET\n version = $1,\n name = $2,\n description = $3,\n store_id = $4,\n deleted = $5;",
|
||||
"query": "UPDATE\n cqrs_ordering_category_query\n SET\n version = $1,\n name = $2,\n description = $3,\n category_id = $4,\n store_id = $5,\n deleted = $6;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
|
|
@ -9,10 +9,11 @@
|
|||
"Text",
|
||||
"Text",
|
||||
"Uuid",
|
||||
"Uuid",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "289e6d9fe105ae9e91d947c22d0a5979786aac15b0c78359b3f634b74c4686d4"
|
||||
"hash": "d896f6ffb486efad5ed10a9c824656d863de0c9140054de66eef32491ace9ddb"
|
||||
}
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_ordering_product_customizations_query\n SET\n version = $1,\n name = $2,\n product_id = $3,\n deleted = $4;",
|
||||
"query": "UPDATE\n cqrs_ordering_product_customizations_query\n SET\n version = $1,\n name = $2,\n customization_id = $3,\n product_id = $4,\n deleted = $5;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
|
|
@ -8,10 +8,11 @@
|
|||
"Int8",
|
||||
"Text",
|
||||
"Uuid",
|
||||
"Uuid",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "a5a58d14ddbfa78cca3729392faecfab30cc8b01fed9b73b9cc0813750230314"
|
||||
"hash": "d9c625876e7d398cb48c6278e69b2eb6ad8515e68d5520013634415109309e6e"
|
||||
}
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "SELECT \n customer_name,\n order_id,\n created_time,\n store_id,\n deleted\n FROM\n cqrs_ordering_order_query\n WHERE\n order_id = $1;",
|
||||
"query": "SELECT \n customer_name,\n order_id,\n created_time,\n deleted\n FROM\n cqrs_ordering_order_query\n WHERE\n order_id = $1;",
|
||||
"describe": {
|
||||
"columns": [
|
||||
{
|
||||
|
|
@ -20,11 +20,6 @@
|
|||
},
|
||||
{
|
||||
"ordinal": 3,
|
||||
"name": "store_id",
|
||||
"type_info": "Uuid"
|
||||
},
|
||||
{
|
||||
"ordinal": 4,
|
||||
"name": "deleted",
|
||||
"type_info": "Bool"
|
||||
}
|
||||
|
|
@ -35,12 +30,11 @@
|
|||
]
|
||||
},
|
||||
"nullable": [
|
||||
true,
|
||||
false,
|
||||
false,
|
||||
false,
|
||||
false
|
||||
]
|
||||
},
|
||||
"hash": "4f8a2294b40e4285fa6d4c7bcf648be7320f99002b9a9279981053a5062b0ed8"
|
||||
"hash": "dbe1e41f04a81b2a504b9179911201ec52340d09d45041addd54eb349af82488"
|
||||
}
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
{
|
||||
"db_name": "PostgreSQL",
|
||||
"query": "UPDATE\n cqrs_ordering_line_item_query\n SET\n version = $1,\n product_name = $2,\n product_id = $3,\n quantity_minor_unit = $4,\n quantity_minor_number = $5,\n quantity_major_unit = $6,\n quantity_major_number = $7,\n created_time = $8,\n kot_id = $9,\n deleted = $10;",
|
||||
"describe": {
|
||||
"columns": [],
|
||||
"parameters": {
|
||||
"Left": [
|
||||
"Int8",
|
||||
"Text",
|
||||
"Uuid",
|
||||
"Text",
|
||||
"Int4",
|
||||
"Text",
|
||||
"Int4",
|
||||
"Timestamptz",
|
||||
"Uuid",
|
||||
"Bool"
|
||||
]
|
||||
},
|
||||
"nullable": []
|
||||
},
|
||||
"hash": "e61db066fe7e66879f8ce8ccd3da94d89c30f8f5d633004ba16a6e971e041a14"
|
||||
}
|
||||
|
|
@ -8,9 +8,8 @@ CREATE TABLE IF NOT EXISTS cqrs_ordering_order_query
|
|||
|
||||
created_time timestamp with time zone DEFAULT (CURRENT_TIMESTAMP) NOT NULL,
|
||||
order_id UUID NOT NULL UNIQUE,
|
||||
store_id UUID NOT NULL,
|
||||
|
||||
customer_name TEXT,
|
||||
customer_name TEXT NOT NULL,
|
||||
|
||||
deleted BOOLEAN NOT NULL DEFAULT FALSE,
|
||||
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ pub mod tests {
|
|||
// use crate::billing::domain::add_product_command::tests::get_customizations;
|
||||
use crate::billing::domain::bill_aggregate::*;
|
||||
|
||||
pub async fn create_dummy_bill(bill: &Bill, db: &BillingDBPostgresAdapter) {
|
||||
async fn create_dummy_bill(bill: &Bill, db: &BillingDBPostgresAdapter) {
|
||||
sqlx::query!(
|
||||
"INSERT INTO cqrs_billing_bill_query (
|
||||
version,
|
||||
|
|
|
|||
|
|
@ -2,8 +2,6 @@
|
|||
//
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
use std::str::FromStr;
|
||||
|
||||
use async_trait::async_trait;
|
||||
use cqrs_es::persist::{PersistenceError, ViewContext, ViewRepository};
|
||||
use cqrs_es::{EventEnvelope, Query, View};
|
||||
|
|
@ -13,9 +11,8 @@ use uuid::Uuid;
|
|||
|
||||
use super::errors::*;
|
||||
use super::BillingDBPostgresAdapter;
|
||||
use crate::billing::domain::bill_aggregate::{Bill, BillBuilder};
|
||||
use crate::billing::domain::bill_aggregate::Bill;
|
||||
use crate::billing::domain::events::BillingEvent;
|
||||
use crate::types::currency::{self, Currency, PriceBuilder};
|
||||
use crate::utils::parse_aggregate_id::parse_aggregate_id;
|
||||
|
||||
pub const NEW_BILL_NON_UUID: &str = "billing_new_bill_non_uuid-asdfa";
|
||||
|
|
@ -37,36 +34,6 @@ pub struct BillView {
|
|||
deleted: bool,
|
||||
}
|
||||
|
||||
impl From<BillView> for Bill {
|
||||
fn from(v: BillView) -> Self {
|
||||
let price = match (
|
||||
v.total_price_minor,
|
||||
v.total_price_major,
|
||||
v.total_price_currency,
|
||||
) {
|
||||
(Some(minor), Some(major), Some(currency)) => Some(
|
||||
PriceBuilder::default()
|
||||
.major(major as usize)
|
||||
.minor(minor as usize)
|
||||
.currency(Currency::from_str(¤cy).unwrap())
|
||||
.build()
|
||||
.unwrap(),
|
||||
),
|
||||
_ => None,
|
||||
};
|
||||
|
||||
BillBuilder::default()
|
||||
.created_time(v.created_time)
|
||||
.store_id(v.store_id)
|
||||
.bill_id(v.bill_id)
|
||||
.token_number(v.token_number as usize)
|
||||
.total_price(price)
|
||||
.deleted(v.deleted)
|
||||
.build()
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for BillView {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
|
|
@ -258,14 +225,17 @@ impl ViewRepository<BillView, Bill> for BillingDBPostgresAdapter {
|
|||
|
||||
created_time = $2,
|
||||
store_id = $3,
|
||||
token_number = $4,
|
||||
total_price_major = $5,
|
||||
total_price_minor = $6,
|
||||
total_price_currency = $7,
|
||||
deleted = $8;",
|
||||
bill_id = $4,
|
||||
token_number = $5,
|
||||
total_price_major = $6,
|
||||
total_price_minor = $7,
|
||||
total_price_currency = $8,
|
||||
|
||||
deleted = $9;",
|
||||
version,
|
||||
view.created_time,
|
||||
view.store_id,
|
||||
view.bill_id,
|
||||
view.token_number,
|
||||
view.total_price_major,
|
||||
view.total_price_minor,
|
||||
|
|
@ -311,136 +281,108 @@ impl Query<Bill> for BillingDBPostgresAdapter {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
// Our second query, this one will be handled with Postgres `GenericQuery`
|
||||
// which will serialize and persist our view after it is updated. It also
|
||||
// provides a `load` method to deserialize the view on request.
|
||||
//pub type BillQuery = GenericQuery<BillingDBPostgresAdapter, BillView, Bill>;
|
||||
//pub type BillQuery = Query<dyn BillingDBPostgresAdapter, BillView, Bill>;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
|
||||
use crate::{
|
||||
billing::{
|
||||
application::services::{
|
||||
add_bill_service::AddBillServiceBuilder, update_bill_service::*,
|
||||
MockBillingServicesInterface,
|
||||
},
|
||||
domain::{
|
||||
add_bill_command::*, commands::BillingCommand, store_aggregate::Store,
|
||||
update_bill_command::*,
|
||||
},
|
||||
},
|
||||
db::migrate::*,
|
||||
tests::bdd::*,
|
||||
utils::uuid::tests::*,
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_billing_bill_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = BillingDBPostgresAdapter::new(db.pool.clone());
|
||||
|
||||
let simple_query = SimpleLoggingQuery {};
|
||||
|
||||
let queries: Vec<Box<dyn Query<Bill>>> = vec![Box::new(simple_query), Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockBillingServicesInterface::new();
|
||||
|
||||
let store = Store::default();
|
||||
crate::billing::adapters::output::db::postgres::store_id_exists::tests::create_dummy_store_record(&store, &db).await;
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_add_bill()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddBillServiceBuilder::default()
|
||||
.db_bill_id_exists(Arc::new(db2.clone()))
|
||||
.db_next_token_id(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_update_bill()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateBillServiceBuilder::default()
|
||||
.db_bill_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, bill_query): (
|
||||
Arc<PostgresCqrs<Bill>>,
|
||||
Arc<dyn ViewRepository<BillView, Bill>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let cmd = AddBillCommandBuilder::default()
|
||||
.adding_by(UUID)
|
||||
.bill_id(UUID)
|
||||
.store_id(*store.store_id())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.bill_id().to_string(),
|
||||
BillingCommand::AddBill(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let bill = bill_query
|
||||
.load(&(*cmd.bill_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let bill: Bill = bill.into();
|
||||
assert_eq!(bill.store_id(), cmd.store_id());
|
||||
assert_eq!(bill.bill_id(), cmd.bill_id());
|
||||
assert!(!bill.deleted());
|
||||
|
||||
let update_bill_cmd = UpdateBillCommandBuilder::default()
|
||||
.adding_by(UUID)
|
||||
.store_id(*store.store_id())
|
||||
.total_price(None)
|
||||
.old_bill(bill.clone())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.bill_id().to_string(),
|
||||
BillingCommand::UpdateBill(update_bill_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let bill = bill_query
|
||||
.load(&(*cmd.bill_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let bill: Bill = bill.into();
|
||||
assert_eq!(bill.store_id(), cmd.store_id());
|
||||
assert_eq!(bill.bill_id(), update_bill_cmd.old_bill().bill_id());
|
||||
assert_eq!(bill.total_price(), update_bill_cmd.total_price());
|
||||
assert!(!bill.deleted());
|
||||
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
//#[cfg(test)]
|
||||
//mod tests {
|
||||
// use super::*;
|
||||
//
|
||||
// use postgres_es::PostgresCqrs;
|
||||
//
|
||||
// use crate::{
|
||||
// db::migrate::*,
|
||||
// billing::{
|
||||
// application::services::{
|
||||
// add_category_service::tests::mock_add_category_service, add_customization_service::tests::mock_add_customization_service, add_line_item_service::tests::mock_add_line_item_service, add_product_service::tests::mock_add_product_service, add_bill_service::AddBillServiceBuilder, update_category_service::tests::mock_update_category_service, update_customization_service::tests::mock_update_customization_service, update_product_service::tests::mock_update_product_service, update_bill_service::tests::mock_update_bill_service, BillingServicesBuilder
|
||||
// },
|
||||
// domain::{
|
||||
// add_category_command::AddCategoryCommand, add_customization_command,
|
||||
// add_product_command::tests::get_command, add_bill_command::AddBillCommand,
|
||||
// commands::BillingCommand,
|
||||
// update_category_command::tests::get_update_category_command,
|
||||
// update_customization_command::tests::get_update_customization_command,
|
||||
// update_product_command, update_bill_command::tests::get_update_bill_cmd,
|
||||
// },
|
||||
// },
|
||||
// tests::bdd::IS_NEVER_CALLED,
|
||||
// utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
|
||||
// };
|
||||
// use std::sync::Arc;
|
||||
//
|
||||
// #[actix_rt::test]
|
||||
// async fn pg_query() {
|
||||
// let settings = crate::settings::tests::get_settings().await;
|
||||
// //let settings = crate::settings::Settings::new().unwrap();
|
||||
// settings.create_db().await;
|
||||
//
|
||||
// let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
// db.migrate().await;
|
||||
// let db = BillingDBPostgresAdapter::new(db.pool.clone());
|
||||
//
|
||||
// let simple_query = SimpleLoggingQuery {};
|
||||
//
|
||||
// let queries: Vec<Box<dyn Query<Bill>>> =
|
||||
// vec![Box::new(simple_query), Box::new(db.clone())];
|
||||
//
|
||||
// let services = BillingServicesBuilder::default()
|
||||
// .add_bill(Arc::new(
|
||||
// AddBillServiceBuilder::default()
|
||||
// .db_bill_id_exists(Arc::new(db.clone()))
|
||||
// .db_bill_name_exists(Arc::new(db.clone()))
|
||||
// .get_uuid(Arc::new(crate::utils::uuid::GenerateUUID {}))
|
||||
// .build()
|
||||
// .unwrap(),
|
||||
// ))
|
||||
// .add_category(mock_add_category_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// AddCategoryCommand::new("foo".into(), None, UUID, UUID).unwrap(),
|
||||
// ))
|
||||
// .add_product(mock_add_product_service(IS_NEVER_CALLED, get_command()))
|
||||
// .add_customization(mock_add_customization_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// add_customization_command::tests::get_command(),
|
||||
// ))
|
||||
// .update_product(mock_update_product_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// update_product_command::tests::get_command(),
|
||||
// ))
|
||||
// .update_customization(mock_update_customization_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// get_update_customization_command(),
|
||||
// ))
|
||||
// .update_category(mock_update_category_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// get_update_category_command(),
|
||||
// ))
|
||||
// .update_bill(mock_update_bill_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// get_update_bill_cmd(),
|
||||
// ))
|
||||
// .build()
|
||||
// .unwrap();
|
||||
//
|
||||
// let (cqrs, _bill_query): (
|
||||
// Arc<PostgresCqrs<Bill>>,
|
||||
// Arc<dyn ViewRepository<BillView, Bill>>,
|
||||
// ) = (
|
||||
// Arc::new(postgres_es::postgres_cqrs(
|
||||
// db.pool.clone(),
|
||||
// queries,
|
||||
// Arc::new(services),
|
||||
// )),
|
||||
// Arc::new(db.clone()),
|
||||
// );
|
||||
//
|
||||
// let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
// let cmd = AddBillCommand::new(rand.get_random(10), None, UUID).unwrap();
|
||||
// cqrs.execute("", BillingCommand::AddBill(cmd.clone()))
|
||||
// .await
|
||||
// .unwrap();
|
||||
//
|
||||
// settings.drop_db().await;
|
||||
// }
|
||||
//}
|
||||
|
|
|
|||
|
|
@ -309,19 +309,21 @@ impl ViewRepository<LineItemView, LineItem> for BillingDBPostgresAdapter {
|
|||
version = $1,
|
||||
product_name = $2,
|
||||
product_id = $3,
|
||||
quantity_minor_unit = $4,
|
||||
quantity_minor_number = $5,
|
||||
quantity_major_unit = $6,
|
||||
quantity_major_number = $7,
|
||||
created_time = $8,
|
||||
bill_id = $9,
|
||||
price_per_unit_minor = $10 ,
|
||||
price_per_unit_major = $11,
|
||||
price_per_unit_currency = $12,
|
||||
deleted = $13;",
|
||||
line_item_id = $4,
|
||||
quantity_minor_unit = $5,
|
||||
quantity_minor_number = $6,
|
||||
quantity_major_unit = $7,
|
||||
quantity_major_number = $8,
|
||||
created_time = $9,
|
||||
bill_id = $10,
|
||||
price_per_unit_minor = $11 ,
|
||||
price_per_unit_major = $12,
|
||||
price_per_unit_currency = $13,
|
||||
deleted = $14;",
|
||||
version,
|
||||
view.product_name,
|
||||
view.product_id,
|
||||
view.line_item_id,
|
||||
view.quantity_minor_unit,
|
||||
view.quantity_minor_number,
|
||||
view.quantity_major_unit,
|
||||
|
|
@ -362,215 +364,3 @@ impl Query<LineItem> for BillingDBPostgresAdapter {
|
|||
self.update_view(view, view_context).await.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
|
||||
use crate::{
|
||||
billing::{
|
||||
application::services::{
|
||||
add_line_item_service::AddLineItemServiceBuilder, delete_line_item_service::*,
|
||||
update_line_item_service::*, MockBillingServicesInterface,
|
||||
},
|
||||
domain::{
|
||||
add_line_item_command::*, bill_aggregate::Bill, commands::BillingCommand,
|
||||
delete_line_item_command::DeleteLineItemCommandBuilder,
|
||||
update_line_item_command::*,
|
||||
},
|
||||
},
|
||||
db::migrate::*,
|
||||
tests::bdd::*,
|
||||
types::quantity::*,
|
||||
utils::{
|
||||
random_string::GenerateRandomStringInterface,
|
||||
uuid::{tests::UUID, *},
|
||||
},
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_billing_line_item_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = BillingDBPostgresAdapter::new(db.pool.clone());
|
||||
|
||||
let queries: Vec<Box<dyn Query<LineItem>>> = vec![Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockBillingServicesInterface::new();
|
||||
|
||||
let bill = Bill::default();
|
||||
crate::billing::adapters::output::db::postgres::bill_id_exists::tests::create_dummy_bill(
|
||||
&bill, &db,
|
||||
)
|
||||
.await;
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_add_line_item()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(Arc::new(db2.clone()))
|
||||
.db_bill_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_update_line_item()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(Arc::new(db2.clone()))
|
||||
.db_bill_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_delete_line_item()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
DeleteLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, line_item_query): (
|
||||
Arc<PostgresCqrs<LineItem>>,
|
||||
Arc<dyn ViewRepository<LineItemView, LineItem>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
let uuid = GenerateUUID {};
|
||||
let line_item_id = uuid.get_uuid();
|
||||
|
||||
let cmd = AddLineItemCommandBuilder::default()
|
||||
.product_name(rand.get_random(10))
|
||||
.adding_by(UUID)
|
||||
.price_per_unit(Price::default())
|
||||
.quantity(Quantity::get_quantity())
|
||||
.product_id(UUID)
|
||||
.bill_id(*bill.bill_id())
|
||||
.line_item_id(line_item_id)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.line_item_id().to_string(),
|
||||
BillingCommand::AddLineItem(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let line_item = line_item_query
|
||||
.load(&(*cmd.line_item_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let line_item: LineItem = line_item.into();
|
||||
assert_eq!(line_item.line_item_id(), cmd.line_item_id());
|
||||
assert_eq!(line_item.product_name(), cmd.product_name());
|
||||
assert_eq!(line_item.product_id(), cmd.product_id());
|
||||
assert_eq!(line_item.quantity(), cmd.quantity());
|
||||
assert!(!line_item.deleted());
|
||||
|
||||
let update_line_item_cmd = UnvalidatedUpdateLineItemCommandBuilder::default()
|
||||
.product_name(rand.get_random(10))
|
||||
.adding_by(UUID)
|
||||
.quantity(Quantity::get_quantity())
|
||||
.product_id(UUID)
|
||||
.bill_id(*bill.bill_id())
|
||||
.old_line_item(line_item.clone())
|
||||
.price_per_unit(Price::default())
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.line_item_id().to_string(),
|
||||
BillingCommand::UpdateLineItem(update_line_item_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let line_item = line_item_query
|
||||
.load(&(*cmd.line_item_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let line_item: LineItem = line_item.into();
|
||||
assert_eq!(
|
||||
line_item.line_item_id(),
|
||||
update_line_item_cmd.old_line_item().line_item_id()
|
||||
);
|
||||
assert_eq!(
|
||||
line_item.product_name(),
|
||||
update_line_item_cmd.product_name()
|
||||
);
|
||||
assert_eq!(line_item.product_id(), update_line_item_cmd.product_id());
|
||||
assert_eq!(line_item.quantity(), update_line_item_cmd.quantity());
|
||||
assert!(!line_item.deleted());
|
||||
|
||||
// delete
|
||||
let delete_line_item_cmd = DeleteLineItemCommandBuilder::default()
|
||||
.line_item(line_item.clone())
|
||||
.adding_by(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.line_item_id().to_string(),
|
||||
BillingCommand::DeleteLineItem(delete_line_item_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let deleted_line_item = line_item_query
|
||||
.load(&(*cmd.line_item_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let deleted_line_item: LineItem = deleted_line_item.into();
|
||||
assert_eq!(
|
||||
deleted_line_item.line_item_id(),
|
||||
delete_line_item_cmd.line_item().line_item_id()
|
||||
);
|
||||
assert_eq!(
|
||||
deleted_line_item.product_name(),
|
||||
delete_line_item_cmd.line_item().product_name()
|
||||
);
|
||||
assert_eq!(
|
||||
deleted_line_item.product_id(),
|
||||
delete_line_item_cmd.line_item().product_id()
|
||||
);
|
||||
assert_eq!(
|
||||
deleted_line_item.quantity(),
|
||||
delete_line_item_cmd.line_item().quantity()
|
||||
);
|
||||
assert!(deleted_line_item.deleted());
|
||||
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ pub mod tests {
|
|||
VALUES ($1, $2, $3, $4, $5 ,$6);",
|
||||
1,
|
||||
s.name(),
|
||||
s.address().as_ref().map(|s| s.as_str()),
|
||||
s.address().as_ref().unwrap(),
|
||||
s.store_id(),
|
||||
s.owner(),
|
||||
false
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use uuid::Uuid;
|
|||
use super::errors::*;
|
||||
use super::BillingDBPostgresAdapter;
|
||||
use crate::billing::domain::events::BillingEvent;
|
||||
use crate::billing::domain::store_aggregate::*;
|
||||
use crate::billing::domain::store_aggregate::Store;
|
||||
use crate::utils::parse_aggregate_id::parse_aggregate_id;
|
||||
|
||||
pub const NEW_STORE_NON_UUID: &str = "billing_new_store_non_uuid-asdfa";
|
||||
|
|
@ -27,19 +27,6 @@ pub struct StoreView {
|
|||
deleted: bool,
|
||||
}
|
||||
|
||||
impl From<StoreView> for Store {
|
||||
fn from(value: StoreView) -> Self {
|
||||
StoreBuilder::default()
|
||||
.name(value.name)
|
||||
.address(value.address)
|
||||
.store_id(value.store_id)
|
||||
.owner(value.owner)
|
||||
.deleted(value.deleted)
|
||||
.build()
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
// This updates the view with events as they are committed.
|
||||
// The logic should be minimal here, e.g., don't calculate the account balance,
|
||||
// design the events to carry the balance information instead.
|
||||
|
|
@ -169,11 +156,13 @@ impl ViewRepository<StoreView, Store> for BillingDBPostgresAdapter {
|
|||
version = $1,
|
||||
name = $2,
|
||||
address = $3,
|
||||
owner = $4,
|
||||
deleted = $5;",
|
||||
store_id = $4,
|
||||
owner = $5,
|
||||
deleted = $6;",
|
||||
version,
|
||||
view.name,
|
||||
view.address,
|
||||
view.store_id,
|
||||
view.owner,
|
||||
view.deleted,
|
||||
)
|
||||
|
|
@ -216,138 +205,108 @@ impl Query<Store> for BillingDBPostgresAdapter {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
// Our second query, this one will be handled with Postgres `GenericQuery`
|
||||
// which will serialize and persist our view after it is updated. It also
|
||||
// provides a `load` method to deserialize the view on request.
|
||||
//pub type StoreQuery = GenericQuery<BillingDBPostgresAdapter, StoreView, Store>;
|
||||
//pub type StoreQuery = Query<dyn BillingDBPostgresAdapter, StoreView, Store>;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
|
||||
use crate::{
|
||||
billing::{
|
||||
application::services::{
|
||||
add_store_service::AddStoreServiceBuilder, update_store_service::*,
|
||||
MockBillingServicesInterface,
|
||||
},
|
||||
domain::add_store_command::*,
|
||||
domain::commands::BillingCommand,
|
||||
domain::update_store_command::*,
|
||||
},
|
||||
db::migrate::*,
|
||||
tests::bdd::*,
|
||||
utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_billing_store_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = BillingDBPostgresAdapter::new(db.pool.clone());
|
||||
|
||||
let simple_query = SimpleLoggingQuery {};
|
||||
|
||||
let queries: Vec<Box<dyn Query<Store>>> =
|
||||
vec![Box::new(simple_query), Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockBillingServicesInterface::new();
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_add_store()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddStoreServiceBuilder::default()
|
||||
.db_store_id_exists(Arc::new(db2.clone()))
|
||||
.db_store_name_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_update_store()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateStoreServiceBuilder::default()
|
||||
.db_store_id_exists(Arc::new(db2.clone()))
|
||||
.db_store_name_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, store_query): (
|
||||
Arc<PostgresCqrs<Store>>,
|
||||
Arc<dyn ViewRepository<StoreView, Store>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(rand.get_random(10))
|
||||
.address(None)
|
||||
.owner(UUID)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.store_id().to_string(),
|
||||
BillingCommand::AddStore(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let store = store_query
|
||||
.load(&(*cmd.store_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let store: Store = store.into();
|
||||
assert_eq!(store.name(), cmd.name());
|
||||
assert_eq!(store.address(), cmd.address());
|
||||
assert_eq!(store.owner(), cmd.owner());
|
||||
assert_eq!(store.store_id(), cmd.store_id());
|
||||
assert!(!store.deleted());
|
||||
|
||||
let update_store_cmd = UpdateStoreCommand::new(
|
||||
rand.get_random(10),
|
||||
Some(rand.get_random(10)),
|
||||
UUID,
|
||||
store,
|
||||
UUID,
|
||||
)
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.store_id().to_string(),
|
||||
BillingCommand::UpdateStore(update_store_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let store = store_query
|
||||
.load(&(*cmd.store_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let store: Store = store.into();
|
||||
assert_eq!(store.name(), update_store_cmd.name());
|
||||
assert_eq!(store.address(), update_store_cmd.address());
|
||||
assert_eq!(store.owner(), update_store_cmd.owner());
|
||||
assert_eq!(store.store_id(), update_store_cmd.old_store().store_id());
|
||||
assert!(!store.deleted());
|
||||
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
//#[cfg(test)]
|
||||
//mod tests {
|
||||
// use super::*;
|
||||
//
|
||||
// use postgres_es::PostgresCqrs;
|
||||
//
|
||||
// use crate::{
|
||||
// db::migrate::*,
|
||||
// billing::{
|
||||
// application::services::{
|
||||
// add_category_service::tests::mock_add_category_service, add_customization_service::tests::mock_add_customization_service, add_line_item_service::tests::mock_add_line_item_service, add_product_service::tests::mock_add_product_service, add_store_service::AddStoreServiceBuilder, update_category_service::tests::mock_update_category_service, update_customization_service::tests::mock_update_customization_service, update_product_service::tests::mock_update_product_service, update_store_service::tests::mock_update_store_service, BillingServicesBuilder
|
||||
// },
|
||||
// domain::{
|
||||
// add_category_command::AddCategoryCommand, add_customization_command,
|
||||
// add_product_command::tests::get_command, add_store_command::AddStoreCommand,
|
||||
// commands::BillingCommand,
|
||||
// update_category_command::tests::get_update_category_command,
|
||||
// update_customization_command::tests::get_update_customization_command,
|
||||
// update_product_command, update_store_command::tests::get_update_store_cmd,
|
||||
// },
|
||||
// },
|
||||
// tests::bdd::IS_NEVER_CALLED,
|
||||
// utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
|
||||
// };
|
||||
// use std::sync::Arc;
|
||||
//
|
||||
// #[actix_rt::test]
|
||||
// async fn pg_query() {
|
||||
// let settings = crate::settings::tests::get_settings().await;
|
||||
// //let settings = crate::settings::Settings::new().unwrap();
|
||||
// settings.create_db().await;
|
||||
//
|
||||
// let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
// db.migrate().await;
|
||||
// let db = BillingDBPostgresAdapter::new(db.pool.clone());
|
||||
//
|
||||
// let simple_query = SimpleLoggingQuery {};
|
||||
//
|
||||
// let queries: Vec<Box<dyn Query<Store>>> =
|
||||
// vec![Box::new(simple_query), Box::new(db.clone())];
|
||||
//
|
||||
// let services = BillingServicesBuilder::default()
|
||||
// .add_store(Arc::new(
|
||||
// AddStoreServiceBuilder::default()
|
||||
// .db_store_id_exists(Arc::new(db.clone()))
|
||||
// .db_store_name_exists(Arc::new(db.clone()))
|
||||
// .get_uuid(Arc::new(crate::utils::uuid::GenerateUUID {}))
|
||||
// .build()
|
||||
// .unwrap(),
|
||||
// ))
|
||||
// .add_category(mock_add_category_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// AddCategoryCommand::new("foo".into(), None, UUID, UUID).unwrap(),
|
||||
// ))
|
||||
// .add_product(mock_add_product_service(IS_NEVER_CALLED, get_command()))
|
||||
// .add_customization(mock_add_customization_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// add_customization_command::tests::get_command(),
|
||||
// ))
|
||||
// .update_product(mock_update_product_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// update_product_command::tests::get_command(),
|
||||
// ))
|
||||
// .update_customization(mock_update_customization_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// get_update_customization_command(),
|
||||
// ))
|
||||
// .update_category(mock_update_category_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// get_update_category_command(),
|
||||
// ))
|
||||
// .update_store(mock_update_store_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// get_update_store_cmd(),
|
||||
// ))
|
||||
// .build()
|
||||
// .unwrap();
|
||||
//
|
||||
// let (cqrs, _store_query): (
|
||||
// Arc<PostgresCqrs<Store>>,
|
||||
// Arc<dyn ViewRepository<StoreView, Store>>,
|
||||
// ) = (
|
||||
// Arc::new(postgres_es::postgres_cqrs(
|
||||
// db.pool.clone(),
|
||||
// queries,
|
||||
// Arc::new(services),
|
||||
// )),
|
||||
// Arc::new(db.clone()),
|
||||
// );
|
||||
//
|
||||
// let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
// let cmd = AddStoreCommand::new(rand.get_random(10), None, UUID).unwrap();
|
||||
// cqrs.execute("", BillingCommand::AddStore(cmd.clone()))
|
||||
// .await
|
||||
// .unwrap();
|
||||
//
|
||||
// settings.drop_db().await;
|
||||
// }
|
||||
//}
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ use crate::billing::{
|
|||
bill_aggregate::*,
|
||||
},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -30,19 +31,27 @@ pub type AddBillServiceObj = Arc<dyn AddBillUseCase>;
|
|||
pub struct AddBillService {
|
||||
db_bill_id_exists: BillIDExistsDBPortObj,
|
||||
db_next_token_id: NextTokenIDDBPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl AddBillUseCase for AddBillService {
|
||||
async fn add_bill(&self, cmd: AddBillCommand) -> BillingResult<BillAddedEvent> {
|
||||
if self.db_bill_id_exists.bill_id_exists(cmd.bill_id()).await? {
|
||||
return Err(BillingError::DuplicateBillID);
|
||||
let mut bill_id = self.get_uuid.get_uuid();
|
||||
|
||||
loop {
|
||||
if self.db_bill_id_exists.bill_id_exists(&bill_id).await? {
|
||||
bill_id = self.get_uuid.get_uuid();
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let token_number = self.db_next_token_id.next_token_id(cmd.store_id()).await?;
|
||||
|
||||
let bill = BillBuilder::default()
|
||||
.bill_id(*cmd.bill_id())
|
||||
.bill_id(bill_id)
|
||||
.token_number(token_number)
|
||||
.created_time(cmd.created_time().clone())
|
||||
.store_id(*cmd.store_id())
|
||||
|
|
@ -71,7 +80,7 @@ pub mod tests {
|
|||
let mut m = MockAddBillUseCase::new();
|
||||
|
||||
let bill = BillBuilder::default()
|
||||
.bill_id(*cmd.bill_id())
|
||||
.bill_id(UUID)
|
||||
.token_number(1)
|
||||
.total_price(None)
|
||||
.created_time(cmd.created_time().clone())
|
||||
|
|
@ -104,6 +113,7 @@ pub mod tests {
|
|||
let s = AddBillServiceBuilder::default()
|
||||
.db_bill_id_exists(mock_bill_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_next_token_id(mock_next_token_id_db_port(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@ use crate::billing::{
|
|||
application::port::output::db::line_item_id_exists::*,
|
||||
domain::{add_line_item_command::*, line_item_added_event::*, line_item_aggregate::*},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -28,6 +29,7 @@ pub type AddLineItemServiceObj = Arc<dyn AddLineItemUseCase>;
|
|||
pub struct AddLineItemService {
|
||||
db_line_item_id_exists: LineItemIDExistsDBPortObj,
|
||||
db_bill_id_exists: BillIDExistsDBPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -37,12 +39,19 @@ impl AddLineItemUseCase for AddLineItemService {
|
|||
return Err(BillingError::BillIDNotFound);
|
||||
}
|
||||
|
||||
let mut line_item_id = self.get_uuid.get_uuid();
|
||||
|
||||
loop {
|
||||
if self
|
||||
.db_line_item_id_exists
|
||||
.line_item_id_exists(cmd.line_item_id())
|
||||
.line_item_id_exists(&line_item_id)
|
||||
.await?
|
||||
{
|
||||
return Err(BillingError::DuplicateLineItemID);
|
||||
line_item_id = self.get_uuid.get_uuid();
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let line_item = LineItemBuilder::default()
|
||||
|
|
@ -50,7 +59,7 @@ impl AddLineItemUseCase for AddLineItemService {
|
|||
.product_name(cmd.product_name().into())
|
||||
.product_id(*cmd.product_id())
|
||||
.bill_id(*cmd.bill_id())
|
||||
.line_item_id(*cmd.line_item_id())
|
||||
.line_item_id(line_item_id)
|
||||
.quantity(cmd.quantity().clone())
|
||||
.price_per_unit(cmd.price_per_unit().clone())
|
||||
.deleted(false)
|
||||
|
|
@ -70,7 +79,8 @@ pub mod tests {
|
|||
use super::*;
|
||||
|
||||
use crate::billing::domain::line_item_added_event::tests::get_added_line_item_event_from_command;
|
||||
use crate::tests::bdd::*;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
|
||||
|
||||
pub fn mock_add_line_item_service(
|
||||
times: Option<usize>,
|
||||
|
|
@ -97,6 +107,7 @@ pub mod tests {
|
|||
let s = AddLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_bill_id_exists(mock_bill_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -118,6 +129,7 @@ pub mod tests {
|
|||
let s = AddLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_NEVER_CALLED))
|
||||
.db_bill_id_exists(mock_bill_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -12,11 +12,12 @@ use super::errors::*;
|
|||
use crate::billing::{
|
||||
application::port::output::db::{store_id_exists::*, store_name_exists::*},
|
||||
domain::{
|
||||
add_store_command::*,
|
||||
add_store_command::AddStoreCommand,
|
||||
store_added_event::{StoreAddedEvent, StoreAddedEventBuilder},
|
||||
store_aggregate::*,
|
||||
},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -30,24 +31,28 @@ pub type AddStoreServiceObj = Arc<dyn AddStoreUseCase>;
|
|||
pub struct AddStoreService {
|
||||
db_store_id_exists: StoreIDExistsDBPortObj,
|
||||
db_store_name_exists: StoreNameExistsDBPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl AddStoreUseCase for AddStoreService {
|
||||
async fn add_store(&self, cmd: AddStoreCommand) -> BillingResult<StoreAddedEvent> {
|
||||
if self
|
||||
.db_store_id_exists
|
||||
.store_id_exists(cmd.store_id())
|
||||
.await?
|
||||
{
|
||||
return Err(BillingError::DuplicateStoreID);
|
||||
let mut store_id = self.get_uuid.get_uuid();
|
||||
|
||||
loop {
|
||||
if self.db_store_id_exists.store_id_exists(&store_id).await? {
|
||||
store_id = self.get_uuid.get_uuid();
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let store = StoreBuilder::default()
|
||||
.name(cmd.name().into())
|
||||
.address(cmd.address().as_ref().map(|s| s.to_string()))
|
||||
.owner(*cmd.owner())
|
||||
.store_id(*cmd.store_id())
|
||||
.store_id(store_id)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -59,7 +64,7 @@ impl AddStoreUseCase for AddStoreService {
|
|||
.name(store.name().into())
|
||||
.address(store.address().as_ref().map(|s| s.to_string()))
|
||||
.owner(*cmd.owner())
|
||||
.store_id(*cmd.store_id())
|
||||
.store_id(store_id)
|
||||
.build()
|
||||
.unwrap())
|
||||
}
|
||||
|
|
@ -82,7 +87,7 @@ pub mod tests {
|
|||
.name(cmd.name().into())
|
||||
.address(cmd.address().as_ref().map(|s| s.to_string()))
|
||||
.owner(*cmd.owner())
|
||||
.store_id(*cmd.store_id())
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -103,17 +108,13 @@ pub mod tests {
|
|||
let address = "bar";
|
||||
let owner = UUID;
|
||||
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(Some(address.into()))
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
// address = None
|
||||
let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
|
||||
|
||||
let s = AddStoreServiceBuilder::default()
|
||||
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_store_name_exists(mock_store_name_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -121,7 +122,7 @@ pub mod tests {
|
|||
assert_eq!(res.name(), cmd.name());
|
||||
assert_eq!(res.address(), cmd.address());
|
||||
assert_eq!(res.owner(), cmd.owner());
|
||||
assert_eq!(res.store_id(), cmd.store_id());
|
||||
assert_eq!(res.store_id(), &UUID);
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
|
|
@ -130,17 +131,13 @@ pub mod tests {
|
|||
let address = "bar";
|
||||
let owner = UUID;
|
||||
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(Some(address.into()))
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
// address = None
|
||||
let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
|
||||
|
||||
let s = AddStoreServiceBuilder::default()
|
||||
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_store_name_exists(mock_store_name_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -15,9 +15,6 @@ pub enum BillingError {
|
|||
BillIDNotFound,
|
||||
InternalError,
|
||||
DuplicateStoreName,
|
||||
DuplicateBillID,
|
||||
DuplicateLineItemID,
|
||||
DuplicateStoreID,
|
||||
StoreIDNotFound,
|
||||
LineItemIDNotFound,
|
||||
}
|
||||
|
|
@ -25,12 +22,21 @@ pub enum BillingError {
|
|||
impl From<BillingDBError> for BillingError {
|
||||
fn from(value: BillingDBError) -> Self {
|
||||
match value {
|
||||
BillingDBError::DuplicateBillID => Self::DuplicateBillID,
|
||||
BillingDBError::DuplicateBillID => {
|
||||
error!("DuplicateBillID");
|
||||
Self::InternalError
|
||||
}
|
||||
BillingDBError::DuplicateStoreName => Self::DuplicateStoreName,
|
||||
BillingDBError::DuplicateStoreID => Self::DuplicateStoreID,
|
||||
BillingDBError::DuplicateStoreID => {
|
||||
error!("DuplicateStoreID");
|
||||
Self::InternalError
|
||||
}
|
||||
BillingDBError::StoreIDNotFound => BillingError::StoreIDNotFound,
|
||||
BillingDBError::InternalError => BillingError::InternalError,
|
||||
BillingDBError::DuplicateLineItemID => Self::DuplicateLineItemID,
|
||||
BillingDBError::DuplicateLineItemID => {
|
||||
error!("DuplicateLineItemID");
|
||||
Self::InternalError
|
||||
}
|
||||
BillingDBError::LineItemIDNotFound => BillingError::LineItemIDNotFound,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,10 +4,14 @@
|
|||
|
||||
use derive_builder::Builder;
|
||||
use derive_getters::Getters;
|
||||
use derive_more::{Display, Error};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use time::OffsetDateTime;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::types::{currency::*, quantity::*};
|
||||
use crate::utils::string::empty_string_err;
|
||||
|
||||
#[derive(
|
||||
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
|
||||
)]
|
||||
|
|
@ -17,7 +21,6 @@ pub struct AddBillCommand {
|
|||
#[builder(default = "OffsetDateTime::now_utc()")]
|
||||
created_time: OffsetDateTime,
|
||||
|
||||
bill_id: Uuid,
|
||||
store_id: Uuid,
|
||||
}
|
||||
|
||||
|
|
@ -38,7 +41,6 @@ mod tests {
|
|||
.adding_by(adding_by)
|
||||
.created_time(datetime!(1970-01-01 0:00 UTC))
|
||||
.store_id(store_id)
|
||||
.bill_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
}
|
||||
|
|
@ -52,7 +54,6 @@ mod tests {
|
|||
let cmd = AddBillCommandBuilder::default()
|
||||
.adding_by(adding_by)
|
||||
.store_id(store_id)
|
||||
.bill_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -19,42 +19,55 @@ pub enum AddLineItemCommandError {
|
|||
}
|
||||
|
||||
#[derive(
|
||||
Clone, Debug, Builder, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
|
||||
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
|
||||
)]
|
||||
#[builder(build_fn(validate = "Self::validate"))]
|
||||
pub struct AddLineItemCommand {
|
||||
pub struct UnvalidatedAddLineItemCommand {
|
||||
adding_by: Uuid,
|
||||
|
||||
#[builder(default = "OffsetDateTime::now_utc()")]
|
||||
created_time: OffsetDateTime,
|
||||
#[builder(setter(custom))]
|
||||
product_name: String,
|
||||
product_id: Uuid,
|
||||
bill_id: Uuid,
|
||||
line_item_id: Uuid,
|
||||
quantity: Quantity,
|
||||
price_per_unit: Price,
|
||||
}
|
||||
|
||||
impl UnvalidatedAddLineItemCommand {
|
||||
pub fn validate(self) -> Result<AddLineItemCommand, AddLineItemCommandError> {
|
||||
let product_name = empty_string_err(
|
||||
self.product_name,
|
||||
AddLineItemCommandError::ProductNameIsEmpty,
|
||||
)?;
|
||||
|
||||
if self.quantity.is_empty() {
|
||||
return Err(AddLineItemCommandError::QuantityIsEmpty);
|
||||
}
|
||||
|
||||
Ok(AddLineItemCommand {
|
||||
created_time: self.created_time,
|
||||
product_name,
|
||||
product_id: self.product_id,
|
||||
bill_id: self.bill_id,
|
||||
quantity: self.quantity,
|
||||
adding_by: self.adding_by,
|
||||
price_per_unit: self.price_per_unit,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
||||
pub struct AddLineItemCommand {
|
||||
created_time: OffsetDateTime,
|
||||
product_name: String,
|
||||
product_id: Uuid,
|
||||
bill_id: Uuid,
|
||||
quantity: Quantity,
|
||||
price_per_unit: Price,
|
||||
|
||||
adding_by: Uuid,
|
||||
}
|
||||
|
||||
impl AddLineItemCommandBuilder {
|
||||
pub fn product_name(&mut self, product_name: String) -> &mut Self {
|
||||
self.product_name = Some(product_name.trim().to_owned());
|
||||
self
|
||||
}
|
||||
|
||||
fn validate(&self) -> Result<(), String> {
|
||||
let product_name = self.product_name.as_ref().unwrap().trim().to_owned();
|
||||
if product_name.is_empty() {
|
||||
return Err(AddLineItemCommandError::ProductNameIsEmpty.to_string());
|
||||
}
|
||||
|
||||
if self.quantity.as_ref().unwrap().is_empty() {
|
||||
return Err(AddLineItemCommandError::QuantityIsEmpty.to_string());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use time::macros::datetime;
|
||||
|
|
@ -71,7 +84,7 @@ mod tests {
|
|||
let adding_by = UUID;
|
||||
let quantity = Quantity::get_quantity();
|
||||
|
||||
AddLineItemCommandBuilder::default()
|
||||
UnvalidatedAddLineItemCommandBuilder::default()
|
||||
.product_name(product_name.into())
|
||||
.adding_by(adding_by)
|
||||
.created_time(datetime!(1970-01-01 0:00 UTC))
|
||||
|
|
@ -79,9 +92,10 @@ mod tests {
|
|||
.price_per_unit(Price::default())
|
||||
.product_id(product_id)
|
||||
.bill_id(bill_id)
|
||||
.line_item_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -93,15 +107,16 @@ mod tests {
|
|||
let adding_by = UUID;
|
||||
let quantity = Quantity::get_quantity();
|
||||
|
||||
let cmd = AddLineItemCommandBuilder::default()
|
||||
let cmd = UnvalidatedAddLineItemCommandBuilder::default()
|
||||
.product_name(product_name.into())
|
||||
.adding_by(adding_by)
|
||||
.price_per_unit(Price::default())
|
||||
.quantity(quantity.clone())
|
||||
.product_id(product_id)
|
||||
.bill_id(bill_id)
|
||||
.line_item_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(cmd.quantity(), &quantity);
|
||||
|
|
@ -118,16 +133,19 @@ mod tests {
|
|||
let adding_by = UUID;
|
||||
let quantity = Quantity::get_quantity();
|
||||
|
||||
assert!(AddLineItemCommandBuilder::default()
|
||||
assert_eq!(
|
||||
UnvalidatedAddLineItemCommandBuilder::default()
|
||||
.product_name(product_name.into())
|
||||
.adding_by(adding_by)
|
||||
.quantity(quantity.clone())
|
||||
.price_per_unit(Price::default())
|
||||
.product_id(product_id)
|
||||
.line_item_id(UUID)
|
||||
.bill_id(bill_id)
|
||||
.build()
|
||||
.is_err());
|
||||
.unwrap()
|
||||
.validate(),
|
||||
Err(AddLineItemCommandError::ProductNameIsEmpty)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -139,7 +157,8 @@ mod tests {
|
|||
// minor = 0; major = 0;
|
||||
let quantity = Quantity::default();
|
||||
|
||||
assert!(AddLineItemCommandBuilder::default()
|
||||
assert_eq!(
|
||||
UnvalidatedAddLineItemCommandBuilder::default()
|
||||
.product_name(product_name.into())
|
||||
.adding_by(adding_by)
|
||||
.quantity(quantity.clone())
|
||||
|
|
@ -147,6 +166,9 @@ mod tests {
|
|||
.bill_id(bill_id)
|
||||
.price_per_unit(Price::default())
|
||||
.build()
|
||||
.is_err());
|
||||
.unwrap()
|
||||
.validate(),
|
||||
Err(AddLineItemCommandError::QuantityIsEmpty)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@
|
|||
//
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
use derive_builder::Builder;
|
||||
use derive_getters::Getters;
|
||||
use derive_more::{Display, Error};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
|
@ -13,52 +12,46 @@ pub enum AddStoreCommandError {
|
|||
NameIsEmpty,
|
||||
}
|
||||
|
||||
#[derive(
|
||||
Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
|
||||
)]
|
||||
#[builder(build_fn(validate = "Self::validate"))]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
||||
pub struct AddStoreCommand {
|
||||
#[builder(setter(custom))]
|
||||
name: String,
|
||||
#[builder(setter(custom))]
|
||||
address: Option<String>,
|
||||
store_id: Uuid,
|
||||
owner: Uuid,
|
||||
}
|
||||
|
||||
impl AddStoreCommandBuilder {
|
||||
pub fn address(&mut self, address: Option<String>) -> &mut Self {
|
||||
self.address = if let Some(address) = address {
|
||||
impl AddStoreCommand {
|
||||
pub fn new(
|
||||
name: String,
|
||||
address: Option<String>,
|
||||
owner: Uuid,
|
||||
) -> Result<Self, AddStoreCommandError> {
|
||||
let address: Option<String> = if let Some(address) = address {
|
||||
let address = address.trim();
|
||||
if address.is_empty() {
|
||||
Some(None)
|
||||
None
|
||||
} else {
|
||||
Some(Some(address.to_owned()))
|
||||
Some(address.to_owned())
|
||||
}
|
||||
} else {
|
||||
Some(None)
|
||||
None
|
||||
};
|
||||
self
|
||||
}
|
||||
|
||||
pub fn name(&mut self, name: String) -> &mut Self {
|
||||
self.name = Some(name.trim().to_owned());
|
||||
self
|
||||
}
|
||||
|
||||
fn validate(&self) -> Result<(), String> {
|
||||
let name = self.name.as_ref().unwrap().trim().to_owned();
|
||||
let name = name.trim().to_owned();
|
||||
if name.is_empty() {
|
||||
return Err(AddStoreCommandError::NameIsEmpty.to_string());
|
||||
return Err(AddStoreCommandError::NameIsEmpty);
|
||||
}
|
||||
Ok(())
|
||||
|
||||
Ok(Self {
|
||||
name,
|
||||
address,
|
||||
owner,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::tests::bdd::*;
|
||||
use crate::utils::uuid::tests::*;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
|
||||
use super::*;
|
||||
|
||||
|
|
@ -69,41 +62,21 @@ mod tests {
|
|||
let owner = UUID;
|
||||
|
||||
// address = None
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(None)
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
// let cmd = AddStoreCommand::new(name.into(), None, owner, UUID).unwrap();
|
||||
let cmd = AddStoreCommand::new(name.into(), None, owner).unwrap();
|
||||
assert_eq!(cmd.name(), name);
|
||||
assert_eq!(cmd.address(), &None);
|
||||
assert_eq!(cmd.owner(), &owner);
|
||||
assert_eq!(*cmd.store_id(), UUID);
|
||||
|
||||
// address = Some
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(Some(address.into()))
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
// let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner, UUID).unwrap();
|
||||
let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
|
||||
assert_eq!(cmd.name(), name);
|
||||
assert_eq!(cmd.address(), &Some(address.to_owned()));
|
||||
assert_eq!(cmd.owner(), &owner);
|
||||
assert_eq!(*cmd.store_id(), UUID);
|
||||
|
||||
// AddStoreCommandError::NameIsEmpty
|
||||
|
||||
assert!(AddStoreCommandBuilder::default()
|
||||
.name("".into())
|
||||
.address(Some(address.into()))
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.is_err())
|
||||
assert_eq!(
|
||||
AddStoreCommand::new("".into(), Some(address.into()), owner),
|
||||
Err(AddStoreCommandError::NameIsEmpty)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ pub mod tests {
|
|||
.quantity(cmd.quantity().clone())
|
||||
.bill_id(*cmd.bill_id())
|
||||
.price_per_unit(cmd.price_per_unit().clone())
|
||||
.line_item_id(*cmd.line_item_id())
|
||||
.line_item_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -113,13 +113,7 @@ mod tests {
|
|||
.unwrap();
|
||||
let expected = BillingEvent::StoreAdded(expected);
|
||||
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(address.clone())
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
let cmd = AddStoreCommand::new(name.into(), address.clone(), owner).unwrap();
|
||||
|
||||
let mut services = MockBillingServicesInterface::new();
|
||||
services
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ pub struct UpdateBillCommand {
|
|||
created_time: OffsetDateTime,
|
||||
|
||||
store_id: Uuid,
|
||||
token_number: usize,
|
||||
total_price: Option<Price>,
|
||||
|
||||
old_bill: Bill,
|
||||
|
|
@ -44,6 +45,7 @@ mod tests {
|
|||
.adding_by(adding_by)
|
||||
.store_id(store_id)
|
||||
.total_price(None)
|
||||
.token_number(1)
|
||||
.old_bill(Bill::get_bill())
|
||||
.build()
|
||||
.unwrap()
|
||||
|
|
@ -60,6 +62,7 @@ mod tests {
|
|||
.adding_by(adding_by)
|
||||
.store_id(store_id)
|
||||
.total_price(None)
|
||||
.token_number(1)
|
||||
.old_bill(old_bill.clone())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ pub mod tests {
|
|||
VALUES ($1, $2, $3, $4, $5, $6);",
|
||||
1,
|
||||
c.name(),
|
||||
c.description().as_ref().map(|s| s.as_str()),
|
||||
c.description().as_ref().unwrap(),
|
||||
c.category_id(),
|
||||
c.store_id(),
|
||||
c.deleted().clone(),
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ use uuid::Uuid;
|
|||
|
||||
use super::errors::*;
|
||||
use super::OrderingDBPostgresAdapter;
|
||||
use crate::ordering::domain::category_aggregate::*;
|
||||
use crate::ordering::domain::category_aggregate::Category;
|
||||
use crate::ordering::domain::events::OrderingEvent;
|
||||
use crate::utils::parse_aggregate_id::parse_aggregate_id;
|
||||
|
||||
|
|
@ -27,19 +27,6 @@ pub struct CategoryView {
|
|||
deleted: bool,
|
||||
}
|
||||
|
||||
impl From<CategoryView> for Category {
|
||||
fn from(v: CategoryView) -> Self {
|
||||
CategoryBuilder::default()
|
||||
.name(v.name)
|
||||
.description(v.description)
|
||||
.category_id(v.category_id)
|
||||
.store_id(v.store_id)
|
||||
.deleted(v.deleted)
|
||||
.build()
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
// This updates the view with events as they are committed.
|
||||
// The logic should be minimal here, e.g., don't calculate the account balance,
|
||||
// design the events to carry the balance information instead.
|
||||
|
|
@ -170,11 +157,13 @@ impl ViewRepository<CategoryView, Category> for OrderingDBPostgresAdapter {
|
|||
version = $1,
|
||||
name = $2,
|
||||
description = $3,
|
||||
store_id = $4,
|
||||
deleted = $5;",
|
||||
category_id = $4,
|
||||
store_id = $5,
|
||||
deleted = $6;",
|
||||
version,
|
||||
view.name,
|
||||
view.description,
|
||||
view.category_id,
|
||||
view.store_id,
|
||||
view.deleted
|
||||
)
|
||||
|
|
@ -221,146 +210,3 @@ impl Query<Category> for OrderingDBPostgresAdapter {
|
|||
self.update_view(view, view_context).await.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
|
||||
use crate::{
|
||||
db::migrate::*,
|
||||
ordering::{
|
||||
application::services::{
|
||||
add_category_service::*, update_category_service::*, MockOrderingServicesInterface,
|
||||
},
|
||||
domain::{
|
||||
add_category_command::*, category_aggregate::*, commands::*, events::*,
|
||||
store_aggregate::*, update_category_command::*,
|
||||
},
|
||||
},
|
||||
tests::bdd::*,
|
||||
utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_ordering_category_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
|
||||
|
||||
let store = Store::default();
|
||||
crate::ordering::adapters::output::db::store_id_exists::tests::create_dummy_store_record(
|
||||
&store, &db,
|
||||
)
|
||||
.await;
|
||||
|
||||
let queries: Vec<Box<dyn Query<Category>>> = vec![Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockOrderingServicesInterface::new();
|
||||
|
||||
let db2 = Arc::new(db.clone());
|
||||
mock_services
|
||||
.expect_add_category()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddCategoryServiceBuilder::default()
|
||||
.db_store_id_exists(db2.clone())
|
||||
.db_category_name_exists_for_store(db2.clone())
|
||||
.db_category_id_exists(db2.clone())
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = Arc::new(db.clone());
|
||||
mock_services
|
||||
.expect_update_category()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateCategoryServiceBuilder::default()
|
||||
.db_store_id_exists(db2.clone())
|
||||
.db_category_name_exists_for_store(db2.clone())
|
||||
.db_category_id_exists(db2.clone())
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, category_query): (
|
||||
Arc<PostgresCqrs<Category>>,
|
||||
Arc<dyn ViewRepository<CategoryView, Category>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
|
||||
let cmd = AddCategoryCommandBuilder::default()
|
||||
.name(rand.get_random(10))
|
||||
.description(None)
|
||||
.store_id(*store.store_id())
|
||||
.adding_by(UUID)
|
||||
.category_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.category_id().to_string(),
|
||||
OrderingCommand::AddCategory(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let category = category_query
|
||||
.load(&(*cmd.category_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let category: Category = category.into();
|
||||
assert_eq!(category.name(), cmd.name());
|
||||
assert_eq!(category.description(), cmd.description());
|
||||
assert_eq!(category.category_id(), cmd.category_id());
|
||||
assert_eq!(category.store_id(), cmd.store_id());
|
||||
assert!(!store.deleted());
|
||||
|
||||
let update_category_cmd = UpdateCategoryCommand::new(
|
||||
rand.get_random(10),
|
||||
Some(rand.get_random(10)),
|
||||
category,
|
||||
UUID,
|
||||
)
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.category_id().to_string(),
|
||||
OrderingCommand::UpdateCategory(update_category_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let category = category_query
|
||||
.load(&(*cmd.category_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let category: Category = category.into();
|
||||
assert_eq!(category.name(), update_category_cmd.name());
|
||||
assert_eq!(category.description(), update_category_cmd.description());
|
||||
assert_eq!(category.category_id(), cmd.category_id());
|
||||
assert_eq!(category.store_id(), cmd.store_id());
|
||||
assert!(!category.deleted());
|
||||
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,6 +17,11 @@ use crate::utils::parse_aggregate_id::parse_aggregate_id;
|
|||
|
||||
pub const NEW_CUSTOMIZATION_NON_UUID: &str = "ordering_new_customization_non_uuid-asdfa";
|
||||
|
||||
//#[derive(Debug, Default, Serialize, Deserialize)]
|
||||
//struct Customizations {
|
||||
// customizations: Vec<CustomizationView>,
|
||||
//}
|
||||
|
||||
#[derive(Debug, Default, Serialize, Deserialize)]
|
||||
struct CustomizationView {
|
||||
name: String,
|
||||
|
|
@ -182,10 +187,12 @@ impl ViewRepository<CustomizationView, Customization> for OrderingDBPostgresAdap
|
|||
SET
|
||||
version = $1,
|
||||
name = $2,
|
||||
product_id = $3,
|
||||
deleted = $4;",
|
||||
customization_id = $3,
|
||||
product_id = $4,
|
||||
deleted = $5;",
|
||||
version,
|
||||
view.name,
|
||||
view.customization_id,
|
||||
view.product_id,
|
||||
view.deleted,
|
||||
)
|
||||
|
|
@ -218,145 +225,3 @@ impl Query<Customization> for OrderingDBPostgresAdapter {
|
|||
self.update_view(view, view_context).await.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
|
||||
use crate::{
|
||||
db::migrate::*,
|
||||
ordering::{
|
||||
adapters::output::db::product_id_exists::tests::create_dummy_product_record,
|
||||
application::services::{
|
||||
add_customization_service::*, update_customization_service::*,
|
||||
MockOrderingServicesInterface,
|
||||
},
|
||||
domain::{
|
||||
add_customization_command::*,
|
||||
commands::OrderingCommand,
|
||||
product_aggregate::Product,
|
||||
update_customization_command::{tests::get_update_customization_command, *},
|
||||
},
|
||||
},
|
||||
tests::bdd::*,
|
||||
utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_ordering_customization_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
|
||||
let product = Product::default();
|
||||
create_dummy_product_record(&product, &db).await;
|
||||
|
||||
// let simple_query = super::store_view::SimpleLoggingQuery {};
|
||||
|
||||
let queries: Vec<Box<dyn Query<Customization>>> = vec![Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockOrderingServicesInterface::new();
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_add_customization()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddCustomizationServiceBuilder::default()
|
||||
.db_product_id_exists(Arc::new(db2.clone()))
|
||||
.db_customization_id_exists(Arc::new(db2.clone()))
|
||||
.db_customization_name_exists_for_product(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = Arc::new(db.clone());
|
||||
mock_services
|
||||
.expect_update_customization()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateCustomizationServiceBuilder::default()
|
||||
.db_product_id_exists(db2.clone())
|
||||
.db_customization_name_exists_for_product(db2.clone())
|
||||
.db_customization_id_exists(db2.clone())
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, custmoization_query): (
|
||||
Arc<PostgresCqrs<Customization>>,
|
||||
Arc<dyn ViewRepository<CustomizationView, Customization>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
|
||||
let cmd = AddCustomizationCommandBuilder::default()
|
||||
.name(rand.get_random(10))
|
||||
.product_id(product.product_id().clone())
|
||||
.customization_id(UUID.clone())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.customization_id().to_string(),
|
||||
OrderingCommand::AddCustomization(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let customization = custmoization_query
|
||||
.load(&(*cmd.customization_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let customization: Customization = customization.into();
|
||||
assert_eq!(customization.name(), cmd.name());
|
||||
assert_eq!(customization.customization_id(), cmd.customization_id());
|
||||
assert_eq!(customization.product_id(), cmd.product_id());
|
||||
assert!(!customization.deleted());
|
||||
|
||||
let update_customization_command = UnvalidatedUpdateCustomizationCommandBuilder::default()
|
||||
.name(rand.get_random(10))
|
||||
.old_customization(customization.clone())
|
||||
.adding_by(UUID.clone())
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.customization_id().to_string(),
|
||||
OrderingCommand::UpdateCustomization(update_customization_command.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let c = custmoization_query
|
||||
.load(&(*cmd.customization_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let c: Customization = c.into();
|
||||
assert_eq!(c.name(), update_customization_command.name());
|
||||
assert_eq!(
|
||||
update_customization_command.old_customization(),
|
||||
&customization
|
||||
);
|
||||
assert!(!c.deleted());
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ pub mod tests {
|
|||
// use crate::ordering::domain::add_product_command::tests::get_customizations;
|
||||
use crate::ordering::domain::kot_aggregate::*;
|
||||
|
||||
pub async fn create_dummy_kot(kot: &Kot, db: &OrderingDBPostgresAdapter) {
|
||||
async fn create_dummy_kot(kot: &Kot, db: &OrderingDBPostgresAdapter) {
|
||||
sqlx::query!(
|
||||
"INSERT INTO cqrs_ordering_kot_query (
|
||||
version,
|
||||
|
|
|
|||
|
|
@ -197,10 +197,12 @@ impl ViewRepository<KotView, Kot> for OrderingDBPostgresAdapter {
|
|||
SET
|
||||
version = $1,
|
||||
order_id = $2,
|
||||
created_time = $3,
|
||||
deleted = $4;",
|
||||
kot_id = $3,
|
||||
created_time = $4,
|
||||
deleted = $5;",
|
||||
version,
|
||||
view.order_id,
|
||||
view.kot_id,
|
||||
view.created_time,
|
||||
view.deleted,
|
||||
)
|
||||
|
|
@ -228,182 +230,3 @@ impl Query<Kot> for OrderingDBPostgresAdapter {
|
|||
self.update_view(view, view_context).await.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
use time::macros::datetime;
|
||||
|
||||
use crate::{
|
||||
db::migrate::*,
|
||||
ordering::{
|
||||
application::services::{
|
||||
add_kot_service::AddKotServiceBuilder, delete_kot_service::DeleteKotServiceBuilder,
|
||||
update_kot_service::*, MockOrderingServicesInterface,
|
||||
},
|
||||
domain::{
|
||||
add_kot_command::*, commands::OrderingCommand,
|
||||
delete_kot_command::DeleteKotCommandBuilder, order_aggregate::Order,
|
||||
update_kot_command::*,
|
||||
},
|
||||
},
|
||||
tests::bdd::*,
|
||||
utils::{
|
||||
random_string::GenerateRandomStringInterface,
|
||||
uuid::{tests::UUID, *},
|
||||
},
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_ordering_kot_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let uuid = GenerateUUID {};
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
|
||||
|
||||
let order = Order::default();
|
||||
crate::ordering::adapters::output::db::order_id_exists::tests::create_dummy_order(
|
||||
&order, &db,
|
||||
)
|
||||
.await;
|
||||
|
||||
let queries: Vec<Box<dyn Query<Kot>>> = vec![Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockOrderingServicesInterface::new();
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_add_kot()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddKotServiceBuilder::default()
|
||||
.db_kot_id_exists(Arc::new(db2.clone()))
|
||||
.db_order_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_update_kot()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateKotServiceBuilder::default()
|
||||
.db_kot_id_exists(Arc::new(db2.clone()))
|
||||
.db_order_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_delete_kot()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
DeleteKotServiceBuilder::default()
|
||||
.db_kot_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, kot_query): (
|
||||
Arc<PostgresCqrs<Kot>>,
|
||||
Arc<dyn ViewRepository<KotView, Kot>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let cmd = AddKotCommandBuilder::default()
|
||||
.adding_by(UUID)
|
||||
.created_time(datetime!(1970-01-01 0:00 UTC))
|
||||
.order_id(*order.order_id())
|
||||
.kot_id(uuid.get_uuid())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.kot_id().to_string(),
|
||||
OrderingCommand::AddKot(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let kot = kot_query
|
||||
.load(&(*cmd.kot_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let kot: Kot = kot.into();
|
||||
assert_eq!(kot.order_id(), cmd.order_id());
|
||||
assert_eq!(kot.kot_id(), cmd.kot_id());
|
||||
assert!(!kot.deleted());
|
||||
|
||||
// update
|
||||
let update_kot_cmd = UpdateKotCommandBuilder::default()
|
||||
.adding_by(UUID)
|
||||
.created_time(datetime!(1970-01-01 1:00 UTC))
|
||||
.order_id(*order.order_id())
|
||||
.old_kot(kot.clone())
|
||||
.build()
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.kot_id().to_string(),
|
||||
OrderingCommand::UpdateKot(update_kot_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let kot = kot_query
|
||||
.load(&(*cmd.kot_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let kot: Kot = kot.into();
|
||||
assert_eq!(kot.order_id(), update_kot_cmd.order_id());
|
||||
assert_eq!(kot.kot_id(), update_kot_cmd.old_kot().kot_id());
|
||||
assert!(!kot.deleted());
|
||||
|
||||
// delete
|
||||
let delete_kot_command = DeleteKotCommandBuilder::default()
|
||||
.kot(kot.clone())
|
||||
.adding_by(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.kot_id().to_string(),
|
||||
OrderingCommand::DeleteKot(delete_kot_command.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let kot = kot_query
|
||||
.load(&(*cmd.kot_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let kot: Kot = kot.into();
|
||||
assert_eq!(kot.order_id(), delete_kot_command.kot().order_id());
|
||||
assert_eq!(kot.kot_id(), delete_kot_command.kot().kot_id());
|
||||
assert!(kot.deleted());
|
||||
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -271,16 +271,18 @@ impl ViewRepository<LineItemView, LineItem> for OrderingDBPostgresAdapter {
|
|||
version = $1,
|
||||
product_name = $2,
|
||||
product_id = $3,
|
||||
quantity_minor_unit = $4,
|
||||
quantity_minor_number = $5,
|
||||
quantity_major_unit = $6,
|
||||
quantity_major_number = $7,
|
||||
created_time = $8,
|
||||
kot_id = $9,
|
||||
deleted = $10;",
|
||||
line_item_id = $4,
|
||||
quantity_minor_unit = $5,
|
||||
quantity_minor_number = $6,
|
||||
quantity_major_unit = $7,
|
||||
quantity_major_number = $8,
|
||||
created_time = $9,
|
||||
kot_id = $10,
|
||||
deleted = $11;",
|
||||
version,
|
||||
view.product_name,
|
||||
view.product_id,
|
||||
view.line_item_id,
|
||||
view.quantity_minor_unit,
|
||||
view.quantity_minor_number,
|
||||
view.quantity_major_unit,
|
||||
|
|
@ -318,211 +320,3 @@ impl Query<LineItem> for OrderingDBPostgresAdapter {
|
|||
self.update_view(view, view_context).await.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
|
||||
use crate::{
|
||||
db::migrate::*,
|
||||
ordering::{
|
||||
application::services::{
|
||||
add_line_item_service::AddLineItemServiceBuilder, delete_line_item_service::*,
|
||||
update_line_item_service::*, MockOrderingServicesInterface,
|
||||
},
|
||||
domain::{
|
||||
add_line_item_command::*, commands::OrderingCommand,
|
||||
delete_line_item_command::DeleteLineItemCommandBuilder, kot_aggregate::Kot,
|
||||
update_line_item_command::*,
|
||||
},
|
||||
},
|
||||
tests::bdd::*,
|
||||
types::quantity::*,
|
||||
utils::{
|
||||
random_string::GenerateRandomStringInterface,
|
||||
uuid::{tests::UUID, *},
|
||||
},
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_ordering_line_item_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
|
||||
|
||||
let queries: Vec<Box<dyn Query<LineItem>>> = vec![Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockOrderingServicesInterface::new();
|
||||
|
||||
let kot = Kot::default();
|
||||
crate::ordering::adapters::output::db::kot_id_exists::tests::create_dummy_kot(&kot, &db)
|
||||
.await;
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_add_line_item()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(Arc::new(db2.clone()))
|
||||
.db_kot_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_update_line_item()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(Arc::new(db2.clone()))
|
||||
.db_kot_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_delete_line_item()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
DeleteLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, line_item_query): (
|
||||
Arc<PostgresCqrs<LineItem>>,
|
||||
Arc<dyn ViewRepository<LineItemView, LineItem>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
let uuid = GenerateUUID {};
|
||||
let line_item_id = uuid.get_uuid();
|
||||
|
||||
let cmd = AddLineItemCommandBuilder::default()
|
||||
.product_name(rand.get_random(10))
|
||||
.adding_by(UUID)
|
||||
.quantity(Quantity::get_quantity())
|
||||
.product_id(UUID)
|
||||
.kot_id(*kot.kot_id())
|
||||
.line_item_id(line_item_id)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.line_item_id().to_string(),
|
||||
OrderingCommand::AddLineItem(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let line_item = line_item_query
|
||||
.load(&(*cmd.line_item_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let line_item: LineItem = line_item.into();
|
||||
assert_eq!(line_item.line_item_id(), cmd.line_item_id());
|
||||
assert_eq!(line_item.product_name(), cmd.product_name());
|
||||
assert_eq!(line_item.product_id(), cmd.product_id());
|
||||
assert_eq!(line_item.quantity(), cmd.quantity());
|
||||
assert!(!line_item.deleted());
|
||||
|
||||
let update_line_item_cmd = UnvalidatedUpdateLineItemCommandBuilder::default()
|
||||
.product_name(rand.get_random(10))
|
||||
.adding_by(UUID)
|
||||
.quantity(Quantity::get_quantity())
|
||||
.product_id(UUID)
|
||||
.kot_id(*kot.kot_id())
|
||||
.old_line_item(line_item.clone())
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.line_item_id().to_string(),
|
||||
OrderingCommand::UpdateLineItem(update_line_item_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let line_item = line_item_query
|
||||
.load(&(*cmd.line_item_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let line_item: LineItem = line_item.into();
|
||||
assert_eq!(
|
||||
line_item.line_item_id(),
|
||||
update_line_item_cmd.old_line_item().line_item_id()
|
||||
);
|
||||
assert_eq!(
|
||||
line_item.product_name(),
|
||||
update_line_item_cmd.product_name()
|
||||
);
|
||||
assert_eq!(line_item.product_id(), update_line_item_cmd.product_id());
|
||||
assert_eq!(line_item.quantity(), update_line_item_cmd.quantity());
|
||||
assert!(!line_item.deleted());
|
||||
|
||||
// delete
|
||||
let delete_line_item_cmd = DeleteLineItemCommandBuilder::default()
|
||||
.line_item(line_item.clone())
|
||||
.adding_by(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.line_item_id().to_string(),
|
||||
OrderingCommand::DeleteLineItem(delete_line_item_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let deleted_line_item = line_item_query
|
||||
.load(&(*cmd.line_item_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let deleted_line_item: LineItem = deleted_line_item.into();
|
||||
assert_eq!(
|
||||
deleted_line_item.line_item_id(),
|
||||
delete_line_item_cmd.line_item().line_item_id()
|
||||
);
|
||||
assert_eq!(
|
||||
deleted_line_item.product_name(),
|
||||
delete_line_item_cmd.line_item().product_name()
|
||||
);
|
||||
assert_eq!(
|
||||
deleted_line_item.product_id(),
|
||||
delete_line_item_cmd.line_item().product_id()
|
||||
);
|
||||
assert_eq!(
|
||||
deleted_line_item.quantity(),
|
||||
delete_line_item_cmd.line_item().quantity()
|
||||
);
|
||||
assert!(deleted_line_item.deleted());
|
||||
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,22 +36,20 @@ pub mod tests {
|
|||
// use crate::ordering::domain::add_order_command::tests::get_customizations;
|
||||
use crate::ordering::domain::order_aggregate::*;
|
||||
|
||||
pub async fn create_dummy_order(order: &Order, db: &OrderingDBPostgresAdapter) {
|
||||
async fn create_dummy_order(order: &Order, db: &OrderingDBPostgresAdapter) {
|
||||
sqlx::query!(
|
||||
"INSERT INTO cqrs_ordering_order_query (
|
||||
version,
|
||||
order_id,
|
||||
store_id,
|
||||
customer_name,
|
||||
created_time,
|
||||
deleted
|
||||
) VALUES (
|
||||
$1, $2, $3, $4, $5, $6
|
||||
$1, $2, $3, $4, $5
|
||||
);",
|
||||
1,
|
||||
order.order_id(),
|
||||
order.store_id(),
|
||||
order.customer_name().as_ref().map(|s| s.as_str()),
|
||||
order.customer_name(),
|
||||
order.created_time(),
|
||||
order.deleted().clone(),
|
||||
)
|
||||
|
|
|
|||
|
|
@ -23,9 +23,8 @@ pub const NEW_ORDER_NON_UUID: &str = "new_order_non_uuid-asdfa";
|
|||
// be designed to reflect the response dto that will be returned to a user.
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
pub struct OrderView {
|
||||
customer_name: Option<String>,
|
||||
customer_name: String,
|
||||
order_id: Uuid,
|
||||
store_id: Uuid,
|
||||
|
||||
created_time: OffsetDateTime,
|
||||
deleted: bool,
|
||||
|
|
@ -37,7 +36,6 @@ impl Default for OrderView {
|
|||
customer_name: Default::default(),
|
||||
order_id: Default::default(),
|
||||
created_time: OffsetDateTime::now_utc(),
|
||||
store_id: Default::default(),
|
||||
deleted: false,
|
||||
}
|
||||
}
|
||||
|
|
@ -48,7 +46,6 @@ impl From<OrderView> for Order {
|
|||
OrderBuilder::default()
|
||||
.customer_name(v.customer_name)
|
||||
.order_id(v.order_id)
|
||||
.store_id(v.store_id)
|
||||
.created_time(v.created_time)
|
||||
.deleted(v.deleted)
|
||||
.build()
|
||||
|
|
@ -63,18 +60,16 @@ impl View<Order> for OrderView {
|
|||
fn update(&mut self, event: &EventEnvelope<Order>) {
|
||||
match &event.payload {
|
||||
OrderingEvent::OrderAdded(val) => {
|
||||
self.customer_name = val.order().customer_name().clone();
|
||||
self.customer_name = val.order().customer_name().into();
|
||||
self.order_id = *val.order().order_id();
|
||||
self.created_time = val.order().created_time().clone();
|
||||
self.store_id = *val.order().store_id();
|
||||
|
||||
self.deleted = false;
|
||||
}
|
||||
OrderingEvent::OrderUpdated(e) => {
|
||||
let new = e.new_order();
|
||||
self.customer_name = new.customer_name().clone();
|
||||
self.customer_name = new.customer_name().into();
|
||||
self.order_id = *new.order_id();
|
||||
self.store_id = *new.store_id();
|
||||
self.created_time = new.created_time().clone();
|
||||
}
|
||||
OrderingEvent::OrderDeleted(_) => self.deleted = true,
|
||||
|
|
@ -98,7 +93,6 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
|
|||
customer_name,
|
||||
order_id,
|
||||
created_time,
|
||||
store_id,
|
||||
deleted
|
||||
FROM
|
||||
cqrs_ordering_order_query
|
||||
|
|
@ -128,7 +122,6 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
|
|||
customer_name,
|
||||
order_id,
|
||||
created_time,
|
||||
store_id,
|
||||
deleted
|
||||
FROM
|
||||
cqrs_ordering_order_query
|
||||
|
|
@ -177,17 +170,15 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
|
|||
customer_name,
|
||||
order_id,
|
||||
created_time,
|
||||
store_id,
|
||||
deleted
|
||||
|
||||
) VALUES (
|
||||
$1, $2, $3, $4, $5, $6
|
||||
$1, $2, $3, $4, $5
|
||||
);",
|
||||
version,
|
||||
view.customer_name,
|
||||
view.order_id,
|
||||
view.created_time,
|
||||
view.store_id,
|
||||
view.deleted,
|
||||
)
|
||||
.execute(&self.pool)
|
||||
|
|
@ -203,13 +194,13 @@ impl ViewRepository<OrderView, Order> for OrderingDBPostgresAdapter {
|
|||
SET
|
||||
version = $1,
|
||||
customer_name = $2,
|
||||
created_time = $3,
|
||||
store_id= $4,
|
||||
order_id = $3,
|
||||
created_time = $4,
|
||||
deleted = $5;",
|
||||
version,
|
||||
view.customer_name,
|
||||
view.order_id,
|
||||
view.created_time,
|
||||
view.store_id,
|
||||
view.deleted,
|
||||
)
|
||||
.execute(&self.pool)
|
||||
|
|
@ -236,187 +227,3 @@ impl Query<Order> for OrderingDBPostgresAdapter {
|
|||
self.update_view(view, view_context).await.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
use time::macros::datetime;
|
||||
|
||||
use crate::{
|
||||
db::migrate::*,
|
||||
ordering::{
|
||||
application::services::{
|
||||
add_order_service::*, delete_order_service::DeleteOrderServiceBuilder,
|
||||
update_order_service::*, MockOrderingServicesInterface,
|
||||
},
|
||||
domain::{
|
||||
add_order_command::*, commands::*, delete_order_command::DeleteOrderCommandBuilder,
|
||||
events::*, order_aggregate::*, store_aggregate::*, update_order_command::*,
|
||||
},
|
||||
},
|
||||
tests::bdd::*,
|
||||
utils::{
|
||||
random_string::GenerateRandomStringInterface,
|
||||
uuid::{tests::UUID, *},
|
||||
},
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_ordering_order_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
|
||||
|
||||
let store = Store::default();
|
||||
crate::ordering::adapters::output::db::store_id_exists::tests::create_dummy_store_record(
|
||||
&store, &db,
|
||||
)
|
||||
.await;
|
||||
|
||||
let queries: Vec<Box<dyn Query<Order>>> = vec![Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockOrderingServicesInterface::new();
|
||||
|
||||
let db2 = Arc::new(db.clone());
|
||||
mock_services
|
||||
.expect_add_order()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddOrderServiceBuilder::default()
|
||||
.db_order_id_exists(db2.clone())
|
||||
.db_store_id_exists(db2.clone())
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = Arc::new(db.clone());
|
||||
mock_services
|
||||
.expect_update_order()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateOrderServiceBuilder::default()
|
||||
.db_order_id_exists(db2.clone())
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = Arc::new(db.clone());
|
||||
mock_services
|
||||
.expect_delete_order()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
DeleteOrderServiceBuilder::default()
|
||||
.db_order_id_exists(db2.clone())
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, order_query): (
|
||||
Arc<PostgresCqrs<Order>>,
|
||||
Arc<dyn ViewRepository<OrderView, Order>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
let uuid = GenerateUUID {};
|
||||
|
||||
let cmd = AddOrderCommandBuilder::default()
|
||||
.customer_name(None)
|
||||
.adding_by(UUID)
|
||||
.created_time(datetime!(1970-01-01 0:00 UTC))
|
||||
.store_id(*store.store_id())
|
||||
.order_id(uuid.get_uuid())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.order_id().to_string(),
|
||||
OrderingCommand::AddOrder(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let order = order_query
|
||||
.load(&(*cmd.order_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let order: Order = order.into();
|
||||
assert_eq!(order.customer_name(), cmd.customer_name());
|
||||
assert_eq!(order.store_id(), cmd.store_id());
|
||||
assert_eq!(order.order_id(), cmd.order_id());
|
||||
assert!(!order.deleted());
|
||||
|
||||
// update
|
||||
let update_order_cmd = UpdateOrderCommandBuilder::default()
|
||||
.customer_name(Some(rand.get_random(10)))
|
||||
.adding_by(UUID)
|
||||
.created_time(datetime!(1970-01-01 0:00 UTC))
|
||||
.old_order(order.clone())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cqrs.execute(
|
||||
&cmd.order_id().to_string(),
|
||||
OrderingCommand::UpdateOrder(update_order_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let order = order_query
|
||||
.load(&(*cmd.order_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let order: Order = order.into();
|
||||
assert_eq!(order.customer_name(), update_order_cmd.customer_name());
|
||||
assert_eq!(order.store_id(), update_order_cmd.old_order().store_id());
|
||||
assert_eq!(order.order_id(), update_order_cmd.old_order().order_id());
|
||||
assert!(!order.deleted());
|
||||
|
||||
let delete_order_cmd = DeleteOrderCommandBuilder::default()
|
||||
.adding_by(UUID)
|
||||
.order(order.clone())
|
||||
.build()
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.order_id().to_string(),
|
||||
OrderingCommand::DeleteOrder(delete_order_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let order = order_query
|
||||
.load(&(*cmd.order_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let order: Order = order.into();
|
||||
assert_eq!(
|
||||
order.customer_name(),
|
||||
delete_order_cmd.order().customer_name()
|
||||
);
|
||||
assert_eq!(order.store_id(), delete_order_cmd.order().store_id());
|
||||
assert_eq!(order.order_id(), delete_order_cmd.order().order_id());
|
||||
assert!(order.deleted());
|
||||
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -95,8 +95,8 @@ pub mod tests {
|
|||
);",
|
||||
1,
|
||||
p.name(),
|
||||
p.description().as_ref().map(|s| s.as_str()),
|
||||
p.image().as_ref().map(|s| s.as_str()),
|
||||
p.description().as_ref().unwrap(),
|
||||
p.image().as_ref().unwrap(),
|
||||
p.product_id(),
|
||||
p.category_id(),
|
||||
p.price().major().clone() as i32,
|
||||
|
|
|
|||
|
|
@ -293,20 +293,22 @@ impl ViewRepository<ProductView, Product> for OrderingDBPostgresAdapter {
|
|||
name = $2,
|
||||
description = $3,
|
||||
image = $4,
|
||||
category_id = $5,
|
||||
price_major = $6,
|
||||
price_minor = $7,
|
||||
price_currency = $8,
|
||||
sku_able = $9,
|
||||
quantity_minor_unit = $10,
|
||||
quantity_minor_number = $11,
|
||||
quantity_major_unit = $12,
|
||||
quantity_major_number = $13,
|
||||
deleted = $14;",
|
||||
product_id = $5,
|
||||
category_id = $6,
|
||||
price_major = $7,
|
||||
price_minor = $8,
|
||||
price_currency = $9,
|
||||
sku_able = $10,
|
||||
quantity_minor_unit = $11,
|
||||
quantity_minor_number = $12,
|
||||
quantity_major_unit = $13,
|
||||
quantity_major_number = $14,
|
||||
deleted = $15;",
|
||||
version,
|
||||
view.name,
|
||||
view.description,
|
||||
view.image,
|
||||
view.product_id,
|
||||
view.category_id,
|
||||
view.price_major,
|
||||
view.price_minor,
|
||||
|
|
@ -347,154 +349,3 @@ impl Query<Product> for OrderingDBPostgresAdapter {
|
|||
self.update_view(view, view_context).await.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
|
||||
use crate::{
|
||||
db::migrate::*,
|
||||
ordering::{
|
||||
application::{
|
||||
port::output::full_text_search::add_product_to_store::*,
|
||||
services::{
|
||||
add_product_service::*, update_product_service::*,
|
||||
MockOrderingServicesInterface,
|
||||
},
|
||||
},
|
||||
domain::{
|
||||
add_product_command::tests::get_command, category_aggregate::*, commands::*,
|
||||
product_aggregate::*, store_aggregate::*,
|
||||
update_product_command::tests::get_command_with_product,
|
||||
},
|
||||
},
|
||||
tests::bdd::*,
|
||||
utils::uuid::tests::UUID,
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_ordering_product_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
|
||||
|
||||
let store = Store::default();
|
||||
crate::ordering::adapters::output::db::store_id_exists::tests::create_dummy_store_record(
|
||||
&store, &db,
|
||||
)
|
||||
.await;
|
||||
let category = CategoryBuilder::default()
|
||||
.name("fooooo_cat".into())
|
||||
.description(None)
|
||||
.store_id(*store.store_id())
|
||||
.category_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
crate::ordering::adapters::output::db::category_name_exists_for_store::tests::create_dummy_category_record(&category, &db).await;
|
||||
|
||||
let queries: Vec<Box<dyn Query<Product>>> = vec![Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockOrderingServicesInterface::new();
|
||||
|
||||
let db2 = Arc::new(db.clone());
|
||||
mock_services
|
||||
.expect_add_product()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddProductServiceBuilder::default()
|
||||
.db_product_name_exists_for_category(db2.clone())
|
||||
.db_product_id_exists(db2.clone())
|
||||
.db_get_category(db2.clone())
|
||||
.db_category_id_exists(db2.clone())
|
||||
.fts_add_product(mock_add_product_to_store_fts_port(IGNORE_CALL_COUNT))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = Arc::new(db.clone());
|
||||
mock_services
|
||||
.expect_update_product()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateProductServiceBuilder::default()
|
||||
.db_category_id_exists(db2.clone())
|
||||
.db_product_name_exists_for_category(db2.clone())
|
||||
.db_product_id_exists(db2.clone())
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, product_query): (
|
||||
Arc<PostgresCqrs<Product>>,
|
||||
Arc<dyn ViewRepository<ProductView, Product>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let cmd = get_command();
|
||||
cqrs.execute(
|
||||
&cmd.product_id().to_string(),
|
||||
OrderingCommand::AddProduct(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let product = product_query
|
||||
.load(&(*cmd.product_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let product: Product = product.into();
|
||||
assert_eq!(product.name(), cmd.name());
|
||||
assert_eq!(product.description(), cmd.description());
|
||||
assert_eq!(product.image(), cmd.image());
|
||||
assert_eq!(product.product_id(), cmd.product_id());
|
||||
assert_eq!(product.quantity(), cmd.quantity());
|
||||
assert_eq!(product.sku_able(), cmd.sku_able());
|
||||
assert_eq!(product.price(), cmd.price());
|
||||
assert!(!product.deleted());
|
||||
|
||||
let update_product_cmd = get_command_with_product(product.clone());
|
||||
cqrs.execute(
|
||||
&cmd.product_id().to_string(),
|
||||
OrderingCommand::UpdateProduct(update_product_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let product = product_query
|
||||
.load(&(*cmd.product_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let product: Product = product.into();
|
||||
assert_eq!(product.name(), update_product_cmd.name());
|
||||
assert_eq!(product.description(), update_product_cmd.description());
|
||||
assert_eq!(product.image(), update_product_cmd.image());
|
||||
assert_eq!(
|
||||
product.product_id(),
|
||||
update_product_cmd.old_product().product_id()
|
||||
);
|
||||
assert_eq!(product.quantity(), update_product_cmd.quantity());
|
||||
assert_eq!(product.sku_able(), update_product_cmd.sku_able());
|
||||
assert_eq!(product.price(), update_product_cmd.price());
|
||||
assert!(!product.deleted());
|
||||
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ pub mod tests {
|
|||
VALUES ($1, $2, $3, $4, $5 ,$6);",
|
||||
1,
|
||||
s.name(),
|
||||
s.address().as_ref().map(|s| s.as_str()),
|
||||
s.address().as_ref().unwrap(),
|
||||
s.store_id(),
|
||||
s.owner(),
|
||||
false
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use uuid::Uuid;
|
|||
use super::errors::*;
|
||||
use super::OrderingDBPostgresAdapter;
|
||||
use crate::ordering::domain::events::OrderingEvent;
|
||||
use crate::ordering::domain::store_aggregate::*;
|
||||
use crate::ordering::domain::store_aggregate::Store;
|
||||
use crate::utils::parse_aggregate_id::parse_aggregate_id;
|
||||
|
||||
pub const NEW_STORE_NON_UUID: &str = "ordering_new_store_non_uuid-asdfa";
|
||||
|
|
@ -27,19 +27,6 @@ pub struct StoreView {
|
|||
deleted: bool,
|
||||
}
|
||||
|
||||
impl From<StoreView> for Store {
|
||||
fn from(value: StoreView) -> Self {
|
||||
StoreBuilder::default()
|
||||
.name(value.name)
|
||||
.address(value.address)
|
||||
.store_id(value.store_id)
|
||||
.owner(value.owner)
|
||||
.deleted(value.deleted)
|
||||
.build()
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
// This updates the view with events as they are committed.
|
||||
// The logic should be minimal here, e.g., don't calculate the account balance,
|
||||
// design the events to carry the balance information instead.
|
||||
|
|
@ -169,11 +156,13 @@ impl ViewRepository<StoreView, Store> for OrderingDBPostgresAdapter {
|
|||
version = $1,
|
||||
name = $2,
|
||||
address = $3,
|
||||
owner = $4,
|
||||
deleted = $5;",
|
||||
store_id = $4,
|
||||
owner = $5,
|
||||
deleted = $6;",
|
||||
version,
|
||||
view.name,
|
||||
view.address,
|
||||
view.store_id,
|
||||
view.owner,
|
||||
view.deleted,
|
||||
)
|
||||
|
|
@ -216,138 +205,108 @@ impl Query<Store> for OrderingDBPostgresAdapter {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
// Our second query, this one will be handled with Postgres `GenericQuery`
|
||||
// which will serialize and persist our view after it is updated. It also
|
||||
// provides a `load` method to deserialize the view on request.
|
||||
//pub type StoreQuery = GenericQuery<OrderingDBPostgresAdapter, StoreView, Store>;
|
||||
//pub type StoreQuery = Query<dyn OrderingDBPostgresAdapter, StoreView, Store>;
|
||||
|
||||
use postgres_es::PostgresCqrs;
|
||||
|
||||
use crate::{
|
||||
db::migrate::*,
|
||||
ordering::{
|
||||
application::services::{
|
||||
add_store_service::AddStoreServiceBuilder, update_store_service::*,
|
||||
MockOrderingServicesInterface,
|
||||
},
|
||||
domain::add_store_command::*,
|
||||
domain::commands::OrderingCommand,
|
||||
domain::update_store_command::*,
|
||||
},
|
||||
tests::bdd::*,
|
||||
utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
|
||||
};
|
||||
use std::sync::Arc;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn pg_query_ordering_store_view() {
|
||||
let settings = crate::settings::tests::get_settings().await;
|
||||
//let settings = crate::settings::Settings::new().unwrap();
|
||||
settings.create_db().await;
|
||||
|
||||
let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
db.migrate().await;
|
||||
let db = OrderingDBPostgresAdapter::new(db.pool.clone());
|
||||
|
||||
let simple_query = SimpleLoggingQuery {};
|
||||
|
||||
let queries: Vec<Box<dyn Query<Store>>> =
|
||||
vec![Box::new(simple_query), Box::new(db.clone())];
|
||||
|
||||
let mut mock_services = MockOrderingServicesInterface::new();
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_add_store()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
AddStoreServiceBuilder::default()
|
||||
.db_store_id_exists(Arc::new(db2.clone()))
|
||||
.db_store_name_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let db2 = db.clone();
|
||||
mock_services
|
||||
.expect_update_store()
|
||||
.times(IS_CALLED_ONLY_ONCE.unwrap())
|
||||
.returning(move || {
|
||||
Arc::new(
|
||||
UpdateStoreServiceBuilder::default()
|
||||
.db_store_id_exists(Arc::new(db2.clone()))
|
||||
.db_store_name_exists(Arc::new(db2.clone()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
|
||||
let (cqrs, store_query): (
|
||||
Arc<PostgresCqrs<Store>>,
|
||||
Arc<dyn ViewRepository<StoreView, Store>>,
|
||||
) = (
|
||||
Arc::new(postgres_es::postgres_cqrs(
|
||||
db.pool.clone(),
|
||||
queries,
|
||||
Arc::new(mock_services),
|
||||
)),
|
||||
Arc::new(db.clone()),
|
||||
);
|
||||
|
||||
let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(rand.get_random(10))
|
||||
.address(None)
|
||||
.owner(UUID)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.store_id().to_string(),
|
||||
OrderingCommand::AddStore(cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let store = store_query
|
||||
.load(&(*cmd.store_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let store: Store = store.into();
|
||||
assert_eq!(store.name(), cmd.name());
|
||||
assert_eq!(store.address(), cmd.address());
|
||||
assert_eq!(store.owner(), cmd.owner());
|
||||
assert_eq!(store.store_id(), cmd.store_id());
|
||||
assert!(!store.deleted());
|
||||
|
||||
let update_store_cmd = UpdateStoreCommand::new(
|
||||
rand.get_random(10),
|
||||
Some(rand.get_random(10)),
|
||||
UUID,
|
||||
store,
|
||||
UUID,
|
||||
)
|
||||
.unwrap();
|
||||
cqrs.execute(
|
||||
&cmd.store_id().to_string(),
|
||||
OrderingCommand::UpdateStore(update_store_cmd.clone()),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let store = store_query
|
||||
.load(&(*cmd.store_id()).to_string())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let store: Store = store.into();
|
||||
assert_eq!(store.name(), update_store_cmd.name());
|
||||
assert_eq!(store.address(), update_store_cmd.address());
|
||||
assert_eq!(store.owner(), update_store_cmd.owner());
|
||||
assert_eq!(store.store_id(), update_store_cmd.old_store().store_id());
|
||||
assert!(!store.deleted());
|
||||
|
||||
settings.drop_db().await;
|
||||
}
|
||||
}
|
||||
//#[cfg(test)]
|
||||
//mod tests {
|
||||
// use super::*;
|
||||
//
|
||||
// use postgres_es::PostgresCqrs;
|
||||
//
|
||||
// use crate::{
|
||||
// db::migrate::*,
|
||||
// ordering::{
|
||||
// application::services::{
|
||||
// add_category_service::tests::mock_add_category_service, add_customization_service::tests::mock_add_customization_service, add_line_item_service::tests::mock_add_line_item_service, add_product_service::tests::mock_add_product_service, add_store_service::AddStoreServiceBuilder, update_category_service::tests::mock_update_category_service, update_customization_service::tests::mock_update_customization_service, update_product_service::tests::mock_update_product_service, update_store_service::tests::mock_update_store_service, OrderingServicesBuilder
|
||||
// },
|
||||
// domain::{
|
||||
// add_category_command::AddCategoryCommand, add_customization_command,
|
||||
// add_product_command::tests::get_command, add_store_command::AddStoreCommand,
|
||||
// commands::OrderingCommand,
|
||||
// update_category_command::tests::get_update_category_command,
|
||||
// update_customization_command::tests::get_update_customization_command,
|
||||
// update_product_command, update_store_command::tests::get_update_store_cmd,
|
||||
// },
|
||||
// },
|
||||
// tests::bdd::IS_NEVER_CALLED,
|
||||
// utils::{random_string::GenerateRandomStringInterface, uuid::tests::UUID},
|
||||
// };
|
||||
// use std::sync::Arc;
|
||||
//
|
||||
// #[actix_rt::test]
|
||||
// async fn pg_query() {
|
||||
// let settings = crate::settings::tests::get_settings().await;
|
||||
// //let settings = crate::settings::Settings::new().unwrap();
|
||||
// settings.create_db().await;
|
||||
//
|
||||
// let db = crate::db::sqlx_postgres::Postgres::init(&settings.database.url).await;
|
||||
// db.migrate().await;
|
||||
// let db = OrderingDBPostgresAdapter::new(db.pool.clone());
|
||||
//
|
||||
// let simple_query = SimpleLoggingQuery {};
|
||||
//
|
||||
// let queries: Vec<Box<dyn Query<Store>>> =
|
||||
// vec![Box::new(simple_query), Box::new(db.clone())];
|
||||
//
|
||||
// let services = OrderingServicesBuilder::default()
|
||||
// .add_store(Arc::new(
|
||||
// AddStoreServiceBuilder::default()
|
||||
// .db_store_id_exists(Arc::new(db.clone()))
|
||||
// .db_store_name_exists(Arc::new(db.clone()))
|
||||
// .get_uuid(Arc::new(crate::utils::uuid::GenerateUUID {}))
|
||||
// .build()
|
||||
// .unwrap(),
|
||||
// ))
|
||||
// .add_category(mock_add_category_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// AddCategoryCommand::new("foo".into(), None, UUID, UUID).unwrap(),
|
||||
// ))
|
||||
// .add_product(mock_add_product_service(IS_NEVER_CALLED, get_command()))
|
||||
// .add_customization(mock_add_customization_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// add_customization_command::tests::get_command(),
|
||||
// ))
|
||||
// .update_product(mock_update_product_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// update_product_command::tests::get_command(),
|
||||
// ))
|
||||
// .update_customization(mock_update_customization_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// get_update_customization_command(),
|
||||
// ))
|
||||
// .update_category(mock_update_category_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// get_update_category_command(),
|
||||
// ))
|
||||
// .update_store(mock_update_store_service(
|
||||
// IS_NEVER_CALLED,
|
||||
// get_update_store_cmd(),
|
||||
// ))
|
||||
// .build()
|
||||
// .unwrap();
|
||||
//
|
||||
// let (cqrs, _store_query): (
|
||||
// Arc<PostgresCqrs<Store>>,
|
||||
// Arc<dyn ViewRepository<StoreView, Store>>,
|
||||
// ) = (
|
||||
// Arc::new(postgres_es::postgres_cqrs(
|
||||
// db.pool.clone(),
|
||||
// queries,
|
||||
// Arc::new(services),
|
||||
// )),
|
||||
// Arc::new(db.clone()),
|
||||
// );
|
||||
//
|
||||
// let rand = crate::utils::random_string::GenerateRandomString {};
|
||||
// let cmd = AddStoreCommand::new(rand.get_random(10), None, UUID).unwrap();
|
||||
// cqrs.execute("", OrderingCommand::AddStore(cmd.clone()))
|
||||
// .await
|
||||
// .unwrap();
|
||||
//
|
||||
// settings.drop_db().await;
|
||||
// }
|
||||
//}
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ use crate::ordering::{
|
|||
category_aggregate::*,
|
||||
},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -33,6 +34,7 @@ pub struct AddCategoryService {
|
|||
db_store_id_exists: StoreIDExistsDBPortObj,
|
||||
db_category_name_exists_for_store: CategoryNameExistsForStoreDBPortObj,
|
||||
db_category_id_exists: CategoryIDExistsDBPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -46,19 +48,27 @@ impl AddCategoryUseCase for AddCategoryService {
|
|||
return Err(OrderingError::StoreIDNotFound);
|
||||
}
|
||||
|
||||
let mut category_id = self.get_uuid.get_uuid();
|
||||
|
||||
loop {
|
||||
if self
|
||||
.db_category_id_exists
|
||||
.category_id_exists(cmd.category_id())
|
||||
.category_id_exists(&category_id)
|
||||
.await?
|
||||
{
|
||||
return Err(OrderingError::DuplicateCategoryID);
|
||||
category_id = self.get_uuid.get_uuid();
|
||||
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let category = CategoryBuilder::default()
|
||||
.name(cmd.name().into())
|
||||
.description(cmd.description().as_ref().map(|s| s.to_string()))
|
||||
.store_id(*cmd.store_id())
|
||||
.category_id(*cmd.category_id())
|
||||
.category_id(category_id)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -87,9 +97,8 @@ pub mod tests {
|
|||
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::tests::bdd::*;
|
||||
|
||||
use crate::ordering::domain::add_category_command::tests::get_add_category_cmd;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
|
||||
|
||||
pub fn mock_add_category_service(
|
||||
times: Option<usize>,
|
||||
|
|
@ -102,7 +111,7 @@ pub mod tests {
|
|||
.description(cmd.description().as_ref().map(|s| s.to_string()))
|
||||
.added_by_user(*cmd.adding_by())
|
||||
.store_id(*cmd.store_id())
|
||||
.category_id(*cmd.category_id())
|
||||
.category_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -119,7 +128,14 @@ pub mod tests {
|
|||
|
||||
#[actix_rt::test]
|
||||
async fn test_service_category_doesnt_exist() {
|
||||
let cmd = get_add_category_cmd();
|
||||
let name = "foo";
|
||||
let description = "bar";
|
||||
let user_id = UUID;
|
||||
let store_id = Uuid::new_v4();
|
||||
|
||||
// description = None
|
||||
let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
|
||||
.unwrap();
|
||||
|
||||
let s = AddCategoryServiceBuilder::default()
|
||||
.db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
|
|
@ -127,6 +143,7 @@ pub mod tests {
|
|||
IS_CALLED_ONLY_ONCE,
|
||||
))
|
||||
.db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -135,12 +152,19 @@ pub mod tests {
|
|||
assert_eq!(res.description(), cmd.description());
|
||||
assert_eq!(res.added_by_user(), cmd.adding_by());
|
||||
assert_eq!(res.store_id(), cmd.store_id());
|
||||
assert_eq!(res.category_id(), cmd.category_id());
|
||||
assert_eq!(res.category_id(), &UUID);
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn test_service_category_name_exists_for_store() {
|
||||
let cmd = get_add_category_cmd();
|
||||
let name = "foo";
|
||||
let description = "bar";
|
||||
let user_id = UUID;
|
||||
let store_id = Uuid::new_v4();
|
||||
|
||||
// description = None
|
||||
let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
|
||||
.unwrap();
|
||||
|
||||
let s = AddCategoryServiceBuilder::default()
|
||||
.db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
|
|
@ -148,6 +172,7 @@ pub mod tests {
|
|||
IS_CALLED_ONLY_ONCE,
|
||||
))
|
||||
.db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -159,7 +184,14 @@ pub mod tests {
|
|||
|
||||
#[actix_rt::test]
|
||||
async fn test_service_store_doesnt_exist() {
|
||||
let cmd = get_add_category_cmd();
|
||||
let name = "foo";
|
||||
let description = "bar";
|
||||
let user_id = UUID;
|
||||
let store_id = Uuid::new_v4();
|
||||
|
||||
// description = None
|
||||
let cmd = AddCategoryCommand::new(name.into(), Some(description.into()), store_id, user_id)
|
||||
.unwrap();
|
||||
|
||||
let s = AddCategoryServiceBuilder::default()
|
||||
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
|
|
@ -167,6 +199,7 @@ pub mod tests {
|
|||
IS_NEVER_CALLED,
|
||||
))
|
||||
.db_category_id_exists(mock_category_id_exists_db_port_false(IS_NEVER_CALLED))
|
||||
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -11,12 +11,20 @@ use mockall::*;
|
|||
use super::errors::*;
|
||||
use crate::ordering::{
|
||||
application::port::output::db::{
|
||||
customization_id_exists::*, customization_name_exists_for_product::*, product_id_exists::*,
|
||||
customization_id_exists::{self, *},
|
||||
customization_name_exists_for_product::*,
|
||||
product_id_exists::{self, *},
|
||||
product_name_exists_for_category::*,
|
||||
},
|
||||
domain::{
|
||||
add_customization_command::*, customization_added_event::*, customization_aggregate::*,
|
||||
add_customization_command::AddCustomizationCommand,
|
||||
customization_added_event::{self, *},
|
||||
customization_aggregate::*,
|
||||
product_added_event::{self, ProductAddedEvent, ProductAddedEventBuilder},
|
||||
product_aggregate::*,
|
||||
},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -34,6 +42,7 @@ pub struct AddCustomizationService {
|
|||
db_product_id_exists: ProductIDExistsDBPortObj,
|
||||
db_customization_id_exists: CustomizationIDExistsDBPortObj,
|
||||
db_customization_name_exists_for_product: CustomizationNameExistsForProductDBPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -50,19 +59,25 @@ impl AddCustomizationUseCase for AddCustomizationService {
|
|||
return Err(OrderingError::ProductIDNotFound);
|
||||
}
|
||||
|
||||
let mut customization_id = self.get_uuid.get_uuid();
|
||||
loop {
|
||||
if self
|
||||
.db_customization_id_exists
|
||||
.customization_id_exists(cmd.customization_id())
|
||||
.customization_id_exists(&customization_id)
|
||||
.await?
|
||||
{
|
||||
return Err(OrderingError::DuplicateCustomizationID);
|
||||
customization_id = self.get_uuid.get_uuid();
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let customization = CustomizationBuilder::default()
|
||||
.name(cmd.name().into())
|
||||
.deleted(false)
|
||||
.product_id(*cmd.product_id())
|
||||
.customization_id(*cmd.customization_id())
|
||||
.customization_id(customization_id)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -85,10 +100,12 @@ impl AddCustomizationUseCase for AddCustomizationService {
|
|||
pub mod tests {
|
||||
use super::*;
|
||||
|
||||
use crate::ordering::domain::{
|
||||
add_customization_command::tests::*, customization_added_event::tests::*,
|
||||
};
|
||||
use crate::tests::bdd::*;
|
||||
use customization_added_event::tests::get_customization_added_event_from_cmd;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::ordering::domain::add_customization_command::tests::get_command;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
|
||||
|
||||
pub fn mock_add_customization_service(
|
||||
times: Option<usize>,
|
||||
|
|
@ -121,15 +138,13 @@ pub mod tests {
|
|||
.db_customization_name_exists_for_product(
|
||||
mock_customization_name_exists_for_product_db_port_false(IS_CALLED_ONLY_ONCE),
|
||||
)
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let res = s.add_customization(cmd.clone()).await.unwrap();
|
||||
assert_eq!(res.customization().name(), cmd.name());
|
||||
assert_eq!(
|
||||
res.customization().customization_id(),
|
||||
cmd.customization_id()
|
||||
);
|
||||
// assert_eq!(customization_added_events.len(), cmd.customizations().len());
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
|
|
@ -144,6 +159,7 @@ pub mod tests {
|
|||
.db_customization_name_exists_for_product(
|
||||
mock_customization_name_exists_for_product_db_port_true(IS_CALLED_ONLY_ONCE),
|
||||
)
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -163,6 +179,7 @@ pub mod tests {
|
|||
.db_customization_name_exists_for_product(
|
||||
mock_customization_name_exists_for_product_db_port_false(IS_NEVER_CALLED),
|
||||
)
|
||||
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ use std::sync::Arc;
|
|||
use derive_builder::Builder;
|
||||
use mockall::predicate::*;
|
||||
use mockall::*;
|
||||
use time::OffsetDateTime;
|
||||
|
||||
use super::errors::*;
|
||||
use crate::ordering::{
|
||||
|
|
@ -14,6 +15,7 @@ use crate::ordering::{
|
|||
application::port::output::db::order_id_exists::*,
|
||||
domain::{add_kot_command::*, kot_added_event::*, kot_aggregate::*},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -27,6 +29,7 @@ pub type AddKotServiceObj = Arc<dyn AddKotUseCase>;
|
|||
pub struct AddKotService {
|
||||
db_kot_id_exists: KotIDExistsDBPortObj,
|
||||
db_order_id_exists: OrderIDExistsDBPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -40,14 +43,21 @@ impl AddKotUseCase for AddKotService {
|
|||
return Err(OrderingError::OrderIDNotFound);
|
||||
}
|
||||
|
||||
if self.db_kot_id_exists.kot_id_exists(cmd.kot_id()).await? {
|
||||
return Err(OrderingError::KotIDNotFound);
|
||||
let mut kot_id = self.get_uuid.get_uuid();
|
||||
|
||||
loop {
|
||||
if self.db_kot_id_exists.kot_id_exists(&kot_id).await? {
|
||||
kot_id = self.get_uuid.get_uuid();
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let kot = KotBuilder::default()
|
||||
.created_time(cmd.created_time().clone())
|
||||
.order_id(*cmd.order_id())
|
||||
.kot_id(*cmd.kot_id())
|
||||
.kot_id(kot_id)
|
||||
.deleted(false)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
|
@ -65,8 +75,8 @@ pub mod tests {
|
|||
use super::*;
|
||||
|
||||
use crate::ordering::domain::kot_added_event::tests::get_added_kot_event_from_command;
|
||||
use crate::tests::bdd::*;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
|
||||
|
||||
pub fn mock_add_kot_service(times: Option<usize>, cmd: AddKotCommand) -> AddKotServiceObj {
|
||||
let mut m = MockAddKotUseCase::new();
|
||||
|
|
@ -90,6 +100,7 @@ pub mod tests {
|
|||
let s = AddKotServiceBuilder::default()
|
||||
.db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_order_id_exists(mock_order_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -107,6 +118,7 @@ pub mod tests {
|
|||
let s = AddKotServiceBuilder::default()
|
||||
.db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_NEVER_CALLED))
|
||||
.db_order_id_exists(mock_order_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@ use crate::ordering::{
|
|||
application::port::output::db::line_item_id_exists::*,
|
||||
domain::{add_line_item_command::*, line_item_added_event::*, line_item_aggregate::*},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -28,6 +29,7 @@ pub type AddLineItemServiceObj = Arc<dyn AddLineItemUseCase>;
|
|||
pub struct AddLineItemService {
|
||||
db_line_item_id_exists: LineItemIDExistsDBPortObj,
|
||||
db_kot_id_exists: KotIDExistsDBPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -37,12 +39,19 @@ impl AddLineItemUseCase for AddLineItemService {
|
|||
return Err(OrderingError::KotIDNotFound);
|
||||
}
|
||||
|
||||
let mut line_item_id = self.get_uuid.get_uuid();
|
||||
|
||||
loop {
|
||||
if self
|
||||
.db_line_item_id_exists
|
||||
.line_item_id_exists(cmd.line_item_id())
|
||||
.line_item_id_exists(&line_item_id)
|
||||
.await?
|
||||
{
|
||||
return Err(OrderingError::DuplicateLineItemID);
|
||||
line_item_id = self.get_uuid.get_uuid();
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let line_item = LineItemBuilder::default()
|
||||
|
|
@ -50,7 +59,7 @@ impl AddLineItemUseCase for AddLineItemService {
|
|||
.product_name(cmd.product_name().into())
|
||||
.product_id(*cmd.product_id())
|
||||
.kot_id(*cmd.kot_id())
|
||||
.line_item_id(*cmd.line_item_id())
|
||||
.line_item_id(line_item_id)
|
||||
.quantity(cmd.quantity().clone())
|
||||
.deleted(false)
|
||||
.build()
|
||||
|
|
@ -69,8 +78,8 @@ pub mod tests {
|
|||
use super::*;
|
||||
|
||||
use crate::ordering::domain::line_item_added_event::tests::get_added_line_item_event_from_command;
|
||||
use crate::tests::bdd::*;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
|
||||
|
||||
pub fn mock_add_line_item_service(
|
||||
times: Option<usize>,
|
||||
|
|
@ -97,6 +106,7 @@ pub mod tests {
|
|||
let s = AddLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_kot_id_exists(mock_kot_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -107,7 +117,6 @@ pub mod tests {
|
|||
assert_eq!(res.line_item().quantity(), cmd.quantity());
|
||||
assert_eq!(res.line_item().quantity(), cmd.quantity());
|
||||
assert_eq!(res.line_item().created_time(), cmd.created_time());
|
||||
assert_eq!(res.line_item().line_item_id(), cmd.line_item_id());
|
||||
assert!(!res.line_item().deleted());
|
||||
assert_eq!(res.added_by_user(), cmd.adding_by());
|
||||
}
|
||||
|
|
@ -119,6 +128,7 @@ pub mod tests {
|
|||
let s = AddLineItemServiceBuilder::default()
|
||||
.db_line_item_id_exists(mock_line_item_id_exists_db_port_false(IS_NEVER_CALLED))
|
||||
.db_kot_id_exists(mock_kot_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -11,9 +11,10 @@ use time::OffsetDateTime;
|
|||
|
||||
use super::errors::*;
|
||||
use crate::ordering::{
|
||||
application::port::output::db::{order_id_exists::*, store_id_exists::*},
|
||||
application::port::output::db::order_id_exists::*,
|
||||
domain::{add_order_command::*, order_added_event::*, order_aggregate::*},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -26,33 +27,27 @@ pub type AddOrderServiceObj = Arc<dyn AddOrderUseCase>;
|
|||
#[derive(Clone, Builder)]
|
||||
pub struct AddOrderService {
|
||||
db_order_id_exists: OrderIDExistsDBPortObj,
|
||||
db_store_id_exists: StoreIDExistsDBPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl AddOrderUseCase for AddOrderService {
|
||||
async fn add_order(&self, cmd: AddOrderCommand) -> OrderingResult<OrderAddedEvent> {
|
||||
if !self
|
||||
.db_store_id_exists
|
||||
.store_id_exists(cmd.store_id())
|
||||
.await?
|
||||
{
|
||||
return Err(OrderingError::StoreIDNotFound);
|
||||
}
|
||||
let mut order_id = self.get_uuid.get_uuid();
|
||||
|
||||
if self
|
||||
.db_order_id_exists
|
||||
.order_id_exists(cmd.order_id())
|
||||
.await?
|
||||
{
|
||||
return Err(OrderingError::DuplicateOrderID);
|
||||
loop {
|
||||
if self.db_order_id_exists.order_id_exists(&order_id).await? {
|
||||
order_id = self.get_uuid.get_uuid();
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let order = OrderBuilder::default()
|
||||
.created_time(OffsetDateTime::now_utc())
|
||||
.customer_name(cmd.customer_name().clone())
|
||||
.order_id(*cmd.order_id())
|
||||
.store_id(*cmd.store_id())
|
||||
.customer_name(cmd.customer_name().into())
|
||||
.order_id(order_id)
|
||||
.deleted(false)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
|
@ -70,7 +65,8 @@ pub mod tests {
|
|||
use super::*;
|
||||
|
||||
use crate::ordering::domain::order_added_event::tests::get_added_order_event_from_command;
|
||||
use crate::tests::bdd::*;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
|
||||
|
||||
pub fn mock_add_order_service(
|
||||
times: Option<usize>,
|
||||
|
|
@ -96,7 +92,7 @@ pub mod tests {
|
|||
|
||||
let s = AddOrderServiceBuilder::default()
|
||||
.db_order_id_exists(mock_order_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_store_id_exists(mock_store_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -104,23 +100,5 @@ pub mod tests {
|
|||
assert_eq!(res.order().customer_name(), cmd.customer_name());
|
||||
assert!(!res.order().deleted());
|
||||
assert_eq!(res.added_by_user(), cmd.adding_by());
|
||||
assert_eq!(res.order().store_id(), cmd.store_id());
|
||||
assert_eq!(res.order().order_id(), cmd.order_id());
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn test_service_store_id_doesnt_exist() {
|
||||
let cmd = AddOrderCommand::get_cmd();
|
||||
|
||||
let s = AddOrderServiceBuilder::default()
|
||||
.db_order_id_exists(mock_order_id_exists_db_port_false(IS_NEVER_CALLED))
|
||||
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(
|
||||
s.add_order(cmd.clone()).await,
|
||||
Err(OrderingError::StoreIDNotFound)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ use crate::ordering::{
|
|||
product_aggregate::*,
|
||||
},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -39,6 +40,7 @@ pub struct AddProductService {
|
|||
db_product_id_exists: ProductIDExistsDBPortObj,
|
||||
db_get_category: GetCategoryDBPortObj,
|
||||
fts_add_product: AddProductToStoreFTSPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -52,12 +54,19 @@ impl AddProductUseCase for AddProductService {
|
|||
return Err(OrderingError::CategoryIDNotFound);
|
||||
}
|
||||
|
||||
let mut product_id = self.get_uuid.get_uuid();
|
||||
|
||||
loop {
|
||||
if self
|
||||
.db_product_id_exists
|
||||
.product_id_exists(cmd.product_id())
|
||||
.product_id_exists(&product_id)
|
||||
.await?
|
||||
{
|
||||
return Err(OrderingError::DuplicateProductID);
|
||||
product_id = self.get_uuid.get_uuid();
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let product = ProductBuilder::default()
|
||||
|
|
@ -68,7 +77,7 @@ impl AddProductUseCase for AddProductService {
|
|||
.price(cmd.price().clone())
|
||||
.category_id(*cmd.category_id())
|
||||
.quantity(cmd.quantity().clone())
|
||||
.product_id(*cmd.product_id())
|
||||
.product_id(product_id)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -110,7 +119,8 @@ pub mod tests {
|
|||
use super::*;
|
||||
|
||||
use crate::ordering::domain::add_product_command::tests::get_command;
|
||||
use crate::tests::bdd::*;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
|
||||
|
||||
pub fn mock_add_product_service(
|
||||
times: Option<usize>,
|
||||
|
|
@ -125,7 +135,7 @@ pub mod tests {
|
|||
.image(cmd.image().as_ref().map(|s| s.to_string()))
|
||||
.sku_able(cmd.sku_able().clone())
|
||||
.category_id(cmd.category_id().clone())
|
||||
.product_id(*cmd.product_id())
|
||||
.product_id(UUID.clone())
|
||||
.price(cmd.price().clone())
|
||||
.quantity(cmd.quantity().clone())
|
||||
.added_by_user(cmd.adding_by().clone())
|
||||
|
|
@ -155,6 +165,7 @@ pub mod tests {
|
|||
.db_get_category(mock_get_category_db_port(IS_CALLED_ONLY_ONCE))
|
||||
.db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
.fts_add_product(mock_add_product_to_store_fts_port(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -166,7 +177,7 @@ pub mod tests {
|
|||
assert_eq!(res.price(), cmd.price());
|
||||
assert_eq!(res.added_by_user(), cmd.adding_by());
|
||||
assert_eq!(res.category_id(), cmd.category_id());
|
||||
assert_eq!(res.product_id(), cmd.product_id());
|
||||
assert_eq!(res.product_id(), &UUID);
|
||||
assert_eq!(res.quantity(), cmd.quantity());
|
||||
}
|
||||
|
||||
|
|
@ -179,6 +190,7 @@ pub mod tests {
|
|||
mock_product_name_exists_for_category_db_port_true(IS_CALLED_ONLY_ONCE),
|
||||
)
|
||||
.db_category_id_exists(mock_category_id_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.db_product_id_exists(mock_product_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_get_category(mock_get_category_db_port(IS_NEVER_CALLED))
|
||||
.fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED))
|
||||
|
|
@ -203,6 +215,7 @@ pub mod tests {
|
|||
.db_category_id_exists(mock_category_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_get_category(mock_get_category_db_port(IS_NEVER_CALLED))
|
||||
.fts_add_product(mock_add_product_to_store_fts_port(IS_NEVER_CALLED))
|
||||
.get_uuid(mock_get_uuid(IS_NEVER_CALLED))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -12,11 +12,12 @@ use super::errors::*;
|
|||
use crate::ordering::{
|
||||
application::port::output::db::{store_id_exists::*, store_name_exists::*},
|
||||
domain::{
|
||||
add_store_command::*,
|
||||
add_store_command::AddStoreCommand,
|
||||
store_added_event::{StoreAddedEvent, StoreAddedEventBuilder},
|
||||
store_aggregate::*,
|
||||
},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -30,24 +31,28 @@ pub type AddStoreServiceObj = Arc<dyn AddStoreUseCase>;
|
|||
pub struct AddStoreService {
|
||||
db_store_id_exists: StoreIDExistsDBPortObj,
|
||||
db_store_name_exists: StoreNameExistsDBPortObj,
|
||||
get_uuid: GetUUIDInterfaceObj,
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl AddStoreUseCase for AddStoreService {
|
||||
async fn add_store(&self, cmd: AddStoreCommand) -> OrderingResult<StoreAddedEvent> {
|
||||
if self
|
||||
.db_store_id_exists
|
||||
.store_id_exists(cmd.store_id())
|
||||
.await?
|
||||
{
|
||||
return Err(OrderingError::DuplicateStoreID);
|
||||
let mut store_id = self.get_uuid.get_uuid();
|
||||
|
||||
loop {
|
||||
if self.db_store_id_exists.store_id_exists(&store_id).await? {
|
||||
store_id = self.get_uuid.get_uuid();
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let store = StoreBuilder::default()
|
||||
.name(cmd.name().into())
|
||||
.address(cmd.address().as_ref().map(|s| s.to_string()))
|
||||
.owner(*cmd.owner())
|
||||
.store_id(*cmd.store_id())
|
||||
.store_id(store_id)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -59,7 +64,7 @@ impl AddStoreUseCase for AddStoreService {
|
|||
.name(store.name().into())
|
||||
.address(store.address().as_ref().map(|s| s.to_string()))
|
||||
.owner(*cmd.owner())
|
||||
.store_id(*cmd.store_id())
|
||||
.store_id(store_id)
|
||||
.build()
|
||||
.unwrap())
|
||||
}
|
||||
|
|
@ -82,7 +87,7 @@ pub mod tests {
|
|||
.name(cmd.name().into())
|
||||
.address(cmd.address().as_ref().map(|s| s.to_string()))
|
||||
.owner(*cmd.owner())
|
||||
.store_id(*cmd.store_id())
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -103,17 +108,13 @@ pub mod tests {
|
|||
let address = "bar";
|
||||
let owner = UUID;
|
||||
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(Some(address.into()))
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
// address = None
|
||||
let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
|
||||
|
||||
let s = AddStoreServiceBuilder::default()
|
||||
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_store_name_exists(mock_store_name_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
@ -121,7 +122,7 @@ pub mod tests {
|
|||
assert_eq!(res.name(), cmd.name());
|
||||
assert_eq!(res.address(), cmd.address());
|
||||
assert_eq!(res.owner(), cmd.owner());
|
||||
assert_eq!(res.store_id(), cmd.store_id());
|
||||
assert_eq!(res.store_id(), &UUID);
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
|
|
@ -130,17 +131,13 @@ pub mod tests {
|
|||
let address = "bar";
|
||||
let owner = UUID;
|
||||
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(Some(address.into()))
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
// address = None
|
||||
let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
|
||||
|
||||
let s = AddStoreServiceBuilder::default()
|
||||
.db_store_id_exists(mock_store_id_exists_db_port_false(IS_CALLED_ONLY_ONCE))
|
||||
.db_store_name_exists(mock_store_name_exists_db_port_true(IS_CALLED_ONLY_ONCE))
|
||||
.get_uuid(mock_get_uuid(IS_CALLED_ONLY_ONCE))
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -42,9 +42,8 @@ impl DeleteOrderUseCase for DeleteOrderService {
|
|||
|
||||
let deleted_order = OrderBuilder::default()
|
||||
.created_time(cmd.order().created_time().clone())
|
||||
.customer_name(cmd.order().customer_name().clone())
|
||||
.customer_name(cmd.order().customer_name().into())
|
||||
.order_id(*cmd.order().order_id())
|
||||
.store_id(*cmd.order().store_id())
|
||||
.deleted(true)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
|
|
|||
|
|
@ -26,37 +26,52 @@ pub enum OrderingError {
|
|||
ProductIDNotFound,
|
||||
DuplicateCustomizationName,
|
||||
CustomizationIDNotFound,
|
||||
|
||||
DuplicateKotID,
|
||||
DuplicateOrderID,
|
||||
DuplicateStoreID,
|
||||
DuplicateCustomizationID,
|
||||
DuplicateProductID,
|
||||
DuplicateCategoryID,
|
||||
DuplicateLineItemID,
|
||||
}
|
||||
//
|
||||
impl From<OrderingDBError> for OrderingError {
|
||||
fn from(value: OrderingDBError) -> Self {
|
||||
match value {
|
||||
OrderingDBError::DuplicateLineItemID => Self::DuplicateLineItemID,
|
||||
OrderingDBError::DuplicateLineItemID => {
|
||||
error!("DuplicateLineItemID");
|
||||
Self::InternalError
|
||||
}
|
||||
OrderingDBError::LineItemIDNotFound => OrderingError::LineItemIDNotFound,
|
||||
OrderingDBError::DuplicateOrderID => Self::DuplicateOrderID,
|
||||
OrderingDBError::DuplicateOrderID => {
|
||||
error!("DuplicateOrderID");
|
||||
Self::InternalError
|
||||
}
|
||||
OrderingDBError::DuplicateStoreName => Self::DuplicateStoreName,
|
||||
OrderingDBError::DuplicateStoreID => Self::DuplicateStoreID,
|
||||
OrderingDBError::DuplicateStoreID => {
|
||||
error!("DuplicateStoreID");
|
||||
Self::InternalError
|
||||
}
|
||||
OrderingDBError::StoreIDNotFound => OrderingError::StoreIDNotFound,
|
||||
|
||||
OrderingDBError::OrderIDNotFound => OrderingError::OrderIDNotFound,
|
||||
OrderingDBError::DuplicateKotID => Self::DuplicateKotID,
|
||||
|
||||
OrderingDBError::DuplicateKotID => {
|
||||
error!("DuplicateKotID");
|
||||
Self::InternalError
|
||||
}
|
||||
OrderingDBError::KotIDNotFound => OrderingError::KotIDNotFound,
|
||||
OrderingDBError::InternalError => Self::InternalError,
|
||||
OrderingDBError::DuplicateCategoryName => Self::DuplicateCategoryName,
|
||||
OrderingDBError::DuplicateCategoryID => Self::DuplicateCategoryID,
|
||||
OrderingDBError::DuplicateCategoryID => {
|
||||
error!("DuplicateCategoryID");
|
||||
Self::InternalError
|
||||
}
|
||||
OrderingDBError::CategoryIDNotFound => OrderingError::CategoryIDNotFound,
|
||||
OrderingDBError::DuplicateProductName => Self::DuplicateProductName,
|
||||
OrderingDBError::DuplicateProductID => Self::DuplicateProductID,
|
||||
OrderingDBError::DuplicateProductID => {
|
||||
error!("DuplicateProductID");
|
||||
Self::InternalError
|
||||
}
|
||||
OrderingDBError::ProductIDNotFound => OrderingError::ProductIDNotFound,
|
||||
OrderingDBError::DuplicateCustomizationName => Self::DuplicateCustomizationName,
|
||||
OrderingDBError::DuplicateCustomizationID => Self::DuplicateCustomizationID,
|
||||
OrderingDBError::DuplicateCustomizationID => {
|
||||
error!("DuplicateCustomizationID");
|
||||
Self::InternalError
|
||||
}
|
||||
OrderingDBError::CustomizationIDNotFound => OrderingError::CustomizationIDNotFound,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,12 +7,14 @@ use std::sync::Arc;
|
|||
use derive_builder::Builder;
|
||||
use mockall::predicate::*;
|
||||
use mockall::*;
|
||||
use time::OffsetDateTime;
|
||||
|
||||
use super::errors::*;
|
||||
use crate::ordering::{
|
||||
application::port::output::db::order_id_exists::*,
|
||||
domain::{order_aggregate::*, order_updated_event::*, update_order_command::*},
|
||||
};
|
||||
use crate::utils::uuid::*;
|
||||
|
||||
#[automock]
|
||||
#[async_trait::async_trait]
|
||||
|
|
@ -40,8 +42,7 @@ impl UpdateOrderUseCase for UpdateOrderService {
|
|||
|
||||
let new_order = OrderBuilder::default()
|
||||
.created_time(cmd.created_time().clone())
|
||||
.customer_name(cmd.customer_name().clone())
|
||||
.store_id(*cmd.old_order().store_id())
|
||||
.customer_name(cmd.customer_name().into())
|
||||
.order_id(*cmd.old_order().order_id())
|
||||
.deleted(false)
|
||||
.build()
|
||||
|
|
@ -61,8 +62,8 @@ pub mod tests {
|
|||
use super::*;
|
||||
|
||||
use crate::ordering::domain::order_updated_event::tests::get_updated_order_event_from_command;
|
||||
use crate::tests::bdd::*;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
use crate::{tests::bdd::*, utils::uuid::tests::mock_get_uuid};
|
||||
|
||||
pub fn mock_update_order_service(
|
||||
times: Option<usize>,
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@
|
|||
//
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
use derive_builder::Builder;
|
||||
use derive_getters::Getters;
|
||||
use derive_more::{Display, Error};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
|
@ -13,22 +12,21 @@ pub enum AddCategoryCommandError {
|
|||
NameIsEmpty,
|
||||
}
|
||||
|
||||
#[derive(
|
||||
Clone, Debug, Builder, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
|
||||
)]
|
||||
#[builder(build_fn(validate = "Self::validate"))]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
||||
pub struct AddCategoryCommand {
|
||||
#[builder(setter(custom))]
|
||||
name: String,
|
||||
#[builder(setter(custom))]
|
||||
description: Option<String>,
|
||||
store_id: Uuid,
|
||||
category_id: Uuid,
|
||||
adding_by: Uuid,
|
||||
}
|
||||
|
||||
impl AddCategoryCommandBuilder {
|
||||
pub fn description(&mut self, description: Option<String>) -> &mut Self {
|
||||
impl AddCategoryCommand {
|
||||
pub fn new(
|
||||
name: String,
|
||||
description: Option<String>,
|
||||
store_id: Uuid,
|
||||
adding_by: Uuid,
|
||||
) -> Result<Self, AddCategoryCommandError> {
|
||||
let description: Option<String> = if let Some(description) = description {
|
||||
let description = description.trim();
|
||||
if description.is_empty() {
|
||||
|
|
@ -39,46 +37,27 @@ impl AddCategoryCommandBuilder {
|
|||
} else {
|
||||
None
|
||||
};
|
||||
self.description = Some(description);
|
||||
self
|
||||
}
|
||||
|
||||
pub fn name(&mut self, name: String) -> &mut Self {
|
||||
let name = name.trim().to_owned();
|
||||
self.name = Some(name);
|
||||
self
|
||||
if name.is_empty() {
|
||||
return Err(AddCategoryCommandError::NameIsEmpty);
|
||||
}
|
||||
|
||||
pub fn validate(&self) -> Result<(), String> {
|
||||
if self.name.as_ref().unwrap().is_empty() {
|
||||
return Err(AddCategoryCommandError::NameIsEmpty.to_string());
|
||||
}
|
||||
|
||||
Ok(())
|
||||
Ok(Self {
|
||||
name,
|
||||
store_id,
|
||||
description,
|
||||
adding_by,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub mod tests {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
|
||||
pub fn get_add_category_cmd() -> AddCategoryCommand {
|
||||
let name = "foo";
|
||||
let adding_by = UUID;
|
||||
let store_id = Uuid::new_v4();
|
||||
|
||||
AddCategoryCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.description(None)
|
||||
.store_id(store_id)
|
||||
.adding_by(adding_by)
|
||||
.category_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_cmd() {
|
||||
let name = "foo";
|
||||
|
|
@ -86,41 +65,26 @@ pub mod tests {
|
|||
let adding_by = UUID;
|
||||
let store_id = Uuid::new_v4();
|
||||
|
||||
let cmd = AddCategoryCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.description(None)
|
||||
.store_id(store_id)
|
||||
.adding_by(adding_by)
|
||||
.category_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
// description = None
|
||||
let cmd = AddCategoryCommand::new(name.into(), None, store_id, adding_by).unwrap();
|
||||
assert_eq!(cmd.name(), name);
|
||||
assert_eq!(cmd.description(), &None);
|
||||
assert_eq!(cmd.adding_by(), &adding_by);
|
||||
assert_eq!(cmd.store_id(), &store_id);
|
||||
|
||||
let cmd = AddCategoryCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.description(Some(description.into()))
|
||||
.store_id(store_id)
|
||||
.adding_by(adding_by)
|
||||
.category_id(UUID)
|
||||
.build()
|
||||
// description = Some
|
||||
let cmd =
|
||||
AddCategoryCommand::new(name.into(), Some(description.into()), store_id, adding_by)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(cmd.name(), name);
|
||||
assert_eq!(cmd.description(), &Some(description.to_owned()));
|
||||
assert_eq!(cmd.adding_by(), &adding_by);
|
||||
assert_eq!(cmd.store_id(), &store_id);
|
||||
|
||||
// AddCategoryCommandError::NameIsEmpty
|
||||
assert!(AddCategoryCommandBuilder::default()
|
||||
.name("".into())
|
||||
.description(Some(description.into()))
|
||||
.store_id(store_id)
|
||||
.adding_by(adding_by)
|
||||
.category_id(UUID)
|
||||
.build()
|
||||
.is_err())
|
||||
assert_eq!(
|
||||
AddCategoryCommand::new("".into(), Some(description.into()), store_id, adding_by,),
|
||||
Err(AddCategoryCommandError::NameIsEmpty)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,26 +16,28 @@ pub enum AddCustomizationCommandError {
|
|||
#[derive(
|
||||
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
|
||||
)]
|
||||
#[builder(build_fn(validate = "Self::validate"))]
|
||||
pub struct AddCustomizationCommand {
|
||||
#[builder(setter(custom))]
|
||||
pub struct UnvalidatedAddCustomizationCommand {
|
||||
name: String,
|
||||
product_id: Uuid,
|
||||
customization_id: Uuid,
|
||||
}
|
||||
|
||||
impl AddCustomizationCommandBuilder {
|
||||
pub fn name(&mut self, name: String) -> &mut Self {
|
||||
self.name = Some(name.trim().to_owned());
|
||||
self
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
||||
pub struct AddCustomizationCommand {
|
||||
name: String,
|
||||
product_id: Uuid,
|
||||
}
|
||||
|
||||
impl UnvalidatedAddCustomizationCommand {
|
||||
pub fn validate(self) -> Result<AddCustomizationCommand, AddCustomizationCommandError> {
|
||||
let name = self.name.trim().to_owned();
|
||||
if name.is_empty() {
|
||||
return Err(AddCustomizationCommandError::NameIsEmpty);
|
||||
}
|
||||
|
||||
fn validate(&self) -> Result<(), String> {
|
||||
let name = self.name.as_ref().unwrap().trim().to_owned();
|
||||
if name.is_empty() {
|
||||
return Err(AddCustomizationCommandError::NameIsEmpty.to_string());
|
||||
}
|
||||
Ok(())
|
||||
Ok(AddCustomizationCommand {
|
||||
name,
|
||||
product_id: self.product_id,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -46,12 +48,13 @@ pub mod tests {
|
|||
use crate::utils::uuid::tests::UUID;
|
||||
|
||||
pub fn get_command() -> AddCustomizationCommand {
|
||||
AddCustomizationCommandBuilder::default()
|
||||
UnvalidatedAddCustomizationCommandBuilder::default()
|
||||
.name("foo".into())
|
||||
.product_id(UUID.clone())
|
||||
.customization_id(UUID.clone())
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -59,11 +62,12 @@ pub mod tests {
|
|||
let name = "foo";
|
||||
let product_id = UUID;
|
||||
|
||||
let cmd = AddCustomizationCommandBuilder::default()
|
||||
let cmd = UnvalidatedAddCustomizationCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.product_id(product_id.clone())
|
||||
.customization_id(UUID.clone())
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(cmd.name(), name);
|
||||
|
|
@ -74,11 +78,14 @@ pub mod tests {
|
|||
fn test_cmd_name_is_empty() {
|
||||
let product_id = UUID;
|
||||
|
||||
assert!(AddCustomizationCommandBuilder::default()
|
||||
assert_eq!(
|
||||
UnvalidatedAddCustomizationCommandBuilder::default()
|
||||
.name("".into())
|
||||
.product_id(product_id.clone())
|
||||
.customization_id(UUID.clone())
|
||||
.build()
|
||||
.is_err(),);
|
||||
.unwrap()
|
||||
.validate(),
|
||||
Err(AddCustomizationCommandError::NameIsEmpty)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@ pub struct AddKotCommand {
|
|||
#[builder(default = "OffsetDateTime::now_utc()")]
|
||||
created_time: OffsetDateTime,
|
||||
order_id: Uuid,
|
||||
kot_id: Uuid,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -37,7 +36,6 @@ mod tests {
|
|||
.adding_by(adding_by)
|
||||
.created_time(datetime!(1970-01-01 0:00 UTC))
|
||||
.order_id(order_id)
|
||||
.kot_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
}
|
||||
|
|
@ -51,12 +49,10 @@ mod tests {
|
|||
let cmd = AddKotCommandBuilder::default()
|
||||
.adding_by(adding_by)
|
||||
.order_id(order_id)
|
||||
.kot_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(*cmd.order_id(), order_id);
|
||||
assert_eq!(*cmd.kot_id(), UUID);
|
||||
assert_eq!(*cmd.adding_by(), adding_by);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
|
|||
use time::OffsetDateTime;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::types::{currency::*, quantity::*};
|
||||
use crate::types::quantity::*;
|
||||
use crate::utils::string::empty_string_err;
|
||||
|
||||
#[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
|
||||
|
|
@ -19,41 +19,52 @@ pub enum AddLineItemCommandError {
|
|||
}
|
||||
|
||||
#[derive(
|
||||
Clone, Debug, Builder, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
|
||||
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
|
||||
)]
|
||||
#[builder(build_fn(validate = "Self::validate"))]
|
||||
pub struct AddLineItemCommand {
|
||||
pub struct UnvalidatedAddLineItemCommand {
|
||||
adding_by: Uuid,
|
||||
|
||||
#[builder(default = "OffsetDateTime::now_utc()")]
|
||||
created_time: OffsetDateTime,
|
||||
#[builder(setter(custom))]
|
||||
product_name: String,
|
||||
product_id: Uuid,
|
||||
kot_id: Uuid,
|
||||
line_item_id: Uuid,
|
||||
quantity: Quantity,
|
||||
}
|
||||
|
||||
impl UnvalidatedAddLineItemCommand {
|
||||
pub fn validate(self) -> Result<AddLineItemCommand, AddLineItemCommandError> {
|
||||
let product_name = empty_string_err(
|
||||
self.product_name,
|
||||
AddLineItemCommandError::ProductNameIsEmpty,
|
||||
)?;
|
||||
|
||||
if self.quantity.is_empty() {
|
||||
return Err(AddLineItemCommandError::QuantityIsEmpty);
|
||||
}
|
||||
|
||||
Ok(AddLineItemCommand {
|
||||
created_time: self.created_time,
|
||||
product_name,
|
||||
product_id: self.product_id,
|
||||
kot_id: self.kot_id,
|
||||
quantity: self.quantity,
|
||||
adding_by: self.adding_by,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
||||
pub struct AddLineItemCommand {
|
||||
created_time: OffsetDateTime,
|
||||
product_name: String,
|
||||
product_id: Uuid,
|
||||
kot_id: Uuid,
|
||||
quantity: Quantity,
|
||||
|
||||
adding_by: Uuid,
|
||||
}
|
||||
|
||||
impl AddLineItemCommandBuilder {
|
||||
pub fn product_name(&mut self, product_name: String) -> &mut Self {
|
||||
self.product_name = Some(product_name.trim().to_owned());
|
||||
self
|
||||
}
|
||||
|
||||
fn validate(&self) -> Result<(), String> {
|
||||
let product_name = self.product_name.as_ref().unwrap().trim().to_owned();
|
||||
if product_name.is_empty() {
|
||||
return Err(AddLineItemCommandError::ProductNameIsEmpty.to_string());
|
||||
}
|
||||
|
||||
if self.quantity.as_ref().unwrap().is_empty() {
|
||||
return Err(AddLineItemCommandError::QuantityIsEmpty.to_string());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use time::macros::datetime;
|
||||
|
|
@ -70,16 +81,17 @@ mod tests {
|
|||
let adding_by = UUID;
|
||||
let quantity = Quantity::get_quantity();
|
||||
|
||||
AddLineItemCommandBuilder::default()
|
||||
UnvalidatedAddLineItemCommandBuilder::default()
|
||||
.product_name(product_name.into())
|
||||
.adding_by(adding_by)
|
||||
.created_time(datetime!(1970-01-01 0:00 UTC))
|
||||
.quantity(quantity.clone())
|
||||
.product_id(product_id)
|
||||
.kot_id(kot_id)
|
||||
.line_item_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -91,14 +103,15 @@ mod tests {
|
|||
let adding_by = UUID;
|
||||
let quantity = Quantity::get_quantity();
|
||||
|
||||
let cmd = AddLineItemCommandBuilder::default()
|
||||
let cmd = UnvalidatedAddLineItemCommandBuilder::default()
|
||||
.product_name(product_name.into())
|
||||
.adding_by(adding_by)
|
||||
.quantity(quantity.clone())
|
||||
.product_id(product_id)
|
||||
.kot_id(kot_id)
|
||||
.line_item_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(cmd.quantity(), &quantity);
|
||||
|
|
@ -115,15 +128,18 @@ mod tests {
|
|||
let adding_by = UUID;
|
||||
let quantity = Quantity::get_quantity();
|
||||
|
||||
assert!(AddLineItemCommandBuilder::default()
|
||||
assert_eq!(
|
||||
UnvalidatedAddLineItemCommandBuilder::default()
|
||||
.product_name(product_name.into())
|
||||
.adding_by(adding_by)
|
||||
.quantity(quantity.clone())
|
||||
.product_id(product_id)
|
||||
.line_item_id(UUID)
|
||||
.kot_id(kot_id)
|
||||
.build()
|
||||
.is_err());
|
||||
.unwrap()
|
||||
.validate(),
|
||||
Err(AddLineItemCommandError::ProductNameIsEmpty)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -135,13 +151,17 @@ mod tests {
|
|||
// minor = 0; major = 0;
|
||||
let quantity = Quantity::default();
|
||||
|
||||
assert!(AddLineItemCommandBuilder::default()
|
||||
assert_eq!(
|
||||
UnvalidatedAddLineItemCommandBuilder::default()
|
||||
.product_name(product_name.into())
|
||||
.adding_by(adding_by)
|
||||
.quantity(quantity.clone())
|
||||
.product_id(product_id)
|
||||
.kot_id(kot_id)
|
||||
.build()
|
||||
.is_err());
|
||||
.unwrap()
|
||||
.validate(),
|
||||
Err(AddLineItemCommandError::QuantityIsEmpty)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,6 +9,8 @@ use serde::{Deserialize, Serialize};
|
|||
use time::OffsetDateTime;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::utils::string::empty_string_err;
|
||||
|
||||
#[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub enum AddOrderCommandError {
|
||||
CustomerNameIsEmpty,
|
||||
|
|
@ -17,33 +19,36 @@ pub enum AddOrderCommandError {
|
|||
#[derive(
|
||||
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
|
||||
)]
|
||||
pub struct AddOrderCommand {
|
||||
pub struct UnvalidatedAddOrderCommand {
|
||||
adding_by: Uuid,
|
||||
|
||||
#[builder(default = "OffsetDateTime::now_utc()")]
|
||||
created_time: OffsetDateTime,
|
||||
#[builder(setter(custom))]
|
||||
customer_name: Option<String>,
|
||||
store_id: Uuid,
|
||||
order_id: Uuid,
|
||||
customer_name: String,
|
||||
}
|
||||
|
||||
impl AddOrderCommandBuilder {
|
||||
pub fn customer_name(&mut self, customer_name: Option<String>) -> &mut Self {
|
||||
self.customer_name = if let Some(customer_name) = customer_name {
|
||||
let customer_name = customer_name.trim();
|
||||
if customer_name.is_empty() {
|
||||
Some(None)
|
||||
} else {
|
||||
Some(Some(customer_name.to_string()))
|
||||
}
|
||||
} else {
|
||||
Some(None)
|
||||
};
|
||||
self
|
||||
impl UnvalidatedAddOrderCommand {
|
||||
pub fn validate(self) -> Result<AddOrderCommand, AddOrderCommandError> {
|
||||
let customer_name = empty_string_err(
|
||||
self.customer_name,
|
||||
AddOrderCommandError::CustomerNameIsEmpty,
|
||||
)?;
|
||||
|
||||
Ok(AddOrderCommand {
|
||||
created_time: self.created_time,
|
||||
customer_name,
|
||||
adding_by: self.adding_by,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
||||
pub struct AddOrderCommand {
|
||||
created_time: OffsetDateTime,
|
||||
customer_name: String,
|
||||
adding_by: Uuid,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use time::macros::datetime;
|
||||
|
|
@ -57,14 +62,14 @@ mod tests {
|
|||
let customer_name = "foo";
|
||||
let adding_by = UUID;
|
||||
|
||||
AddOrderCommandBuilder::default()
|
||||
.customer_name(Some(customer_name.into()))
|
||||
UnvalidatedAddOrderCommandBuilder::default()
|
||||
.customer_name(customer_name.into())
|
||||
.adding_by(adding_by)
|
||||
.created_time(datetime!(1970-01-01 0:00 UTC))
|
||||
.store_id(UUID)
|
||||
.order_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -73,27 +78,31 @@ mod tests {
|
|||
let customer_name = "foo";
|
||||
let adding_by = UUID;
|
||||
|
||||
let _cmd = AddOrderCommandBuilder::default()
|
||||
.customer_name(Some(customer_name.into()))
|
||||
let cmd = UnvalidatedAddOrderCommandBuilder::default()
|
||||
.customer_name(customer_name.into())
|
||||
.adding_by(adding_by)
|
||||
.store_id(UUID)
|
||||
.order_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(*cmd.adding_by(), adding_by);
|
||||
assert_eq!(cmd.customer_name(), customer_name);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_cmd_customer_name_empty() {
|
||||
let customer_name = "";
|
||||
let adding_by = UUID;
|
||||
|
||||
let cmd = AddOrderCommandBuilder::default()
|
||||
.customer_name(Some(customer_name.into()))
|
||||
.adding_by(UUID)
|
||||
.store_id(UUID)
|
||||
.order_id(UUID)
|
||||
assert_eq!(
|
||||
UnvalidatedAddOrderCommandBuilder::default()
|
||||
.customer_name(customer_name.into())
|
||||
.adding_by(adding_by)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
assert!(cmd.customer_name().is_none());
|
||||
.unwrap()
|
||||
.validate(),
|
||||
Err(AddOrderCommandError::CustomerNameIsEmpty)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,17 +17,24 @@ pub enum AddProductCommandError {
|
|||
}
|
||||
|
||||
#[derive(
|
||||
Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
|
||||
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
|
||||
)]
|
||||
#[builder(build_fn(validate = "Self::validate"))]
|
||||
pub struct AddProductCommand {
|
||||
#[builder(setter(custom))]
|
||||
pub struct UnvalidatedAddProductCommand {
|
||||
name: String,
|
||||
description: Option<String>,
|
||||
image: Option<String>,
|
||||
category_id: Uuid,
|
||||
sku_able: bool,
|
||||
quantity: Quantity,
|
||||
price: Price,
|
||||
adding_by: Uuid,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
||||
pub struct AddProductCommand {
|
||||
name: String,
|
||||
#[builder(setter(custom))]
|
||||
description: Option<String>,
|
||||
#[builder(setter(custom))]
|
||||
image: Option<String>,
|
||||
product_id: Uuid,
|
||||
category_id: Uuid,
|
||||
sku_able: bool,
|
||||
price: Price,
|
||||
|
|
@ -35,9 +42,9 @@ pub struct AddProductCommand {
|
|||
adding_by: Uuid,
|
||||
}
|
||||
|
||||
impl AddProductCommandBuilder {
|
||||
pub fn description(&mut self, description: Option<String>) -> &mut Self {
|
||||
let description: Option<String> = if let Some(description) = description {
|
||||
impl UnvalidatedAddProductCommand {
|
||||
pub fn validate(self) -> Result<AddProductCommand, AddProductCommandError> {
|
||||
let description: Option<String> = if let Some(description) = self.description {
|
||||
let description = description.trim();
|
||||
if description.is_empty() {
|
||||
None
|
||||
|
|
@ -47,12 +54,8 @@ impl AddProductCommandBuilder {
|
|||
} else {
|
||||
None
|
||||
};
|
||||
self.description = Some(description);
|
||||
self
|
||||
}
|
||||
|
||||
pub fn image(&mut self, image: Option<String>) -> &mut Self {
|
||||
let image: Option<String> = if let Some(image) = image {
|
||||
let image: Option<String> = if let Some(image) = self.image {
|
||||
let image = image.trim();
|
||||
if image.is_empty() {
|
||||
None
|
||||
|
|
@ -62,22 +65,22 @@ impl AddProductCommandBuilder {
|
|||
} else {
|
||||
None
|
||||
};
|
||||
self.image = Some(image);
|
||||
self
|
||||
|
||||
let name = self.name.trim().to_owned();
|
||||
if name.is_empty() {
|
||||
return Err(AddProductCommandError::NameIsEmpty);
|
||||
}
|
||||
|
||||
pub fn name(&mut self, name: String) -> &mut Self {
|
||||
let name = name.trim().to_owned();
|
||||
self.name = Some(name);
|
||||
self
|
||||
}
|
||||
|
||||
pub fn validate(&self) -> Result<(), String> {
|
||||
if self.name.as_ref().unwrap().is_empty() {
|
||||
return Err(AddProductCommandError::NameIsEmpty.to_string());
|
||||
}
|
||||
|
||||
Ok(())
|
||||
Ok(AddProductCommand {
|
||||
name,
|
||||
description,
|
||||
image,
|
||||
category_id: self.category_id,
|
||||
sku_able: self.sku_able,
|
||||
price: self.price,
|
||||
quantity: self.quantity,
|
||||
adding_by: self.adding_by,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -90,7 +93,7 @@ pub mod tests {
|
|||
pub fn get_command() -> AddProductCommand {
|
||||
let name = "foo";
|
||||
let adding_by = UUID;
|
||||
let category_id = UUID;
|
||||
let category_id = Uuid::new_v4();
|
||||
let sku_able = false;
|
||||
let image = Some("image".to_string());
|
||||
let description = Some("description".to_string());
|
||||
|
|
@ -120,7 +123,7 @@ pub mod tests {
|
|||
.build()
|
||||
.unwrap();
|
||||
|
||||
AddProductCommandBuilder::default()
|
||||
let cmd = UnvalidatedAddProductCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.description(description.clone())
|
||||
.image(image.clone())
|
||||
|
|
@ -128,10 +131,11 @@ pub mod tests {
|
|||
.adding_by(adding_by)
|
||||
.quantity(quantity)
|
||||
.sku_able(sku_able)
|
||||
.product_id(UUID)
|
||||
.price(price.clone())
|
||||
.build()
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
|
||||
cmd.validate().unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -151,7 +155,7 @@ pub mod tests {
|
|||
let quantity = Quantity::default();
|
||||
|
||||
// description = None
|
||||
let cmd = AddProductCommandBuilder::default()
|
||||
let cmd = UnvalidatedAddProductCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.description(None)
|
||||
.image(None)
|
||||
|
|
@ -159,11 +163,12 @@ pub mod tests {
|
|||
.adding_by(adding_by)
|
||||
.quantity(quantity.clone())
|
||||
.sku_able(sku_able)
|
||||
.product_id(UUID)
|
||||
.price(price.clone())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let cmd = cmd.validate().unwrap();
|
||||
|
||||
assert_eq!(cmd.name(), name);
|
||||
assert_eq!(cmd.description(), &None);
|
||||
assert_eq!(cmd.adding_by(), &adding_by);
|
||||
|
|
@ -191,19 +196,21 @@ pub mod tests {
|
|||
|
||||
let quantity = Quantity::default();
|
||||
|
||||
let cmd = AddProductCommandBuilder::default()
|
||||
let cmd = UnvalidatedAddProductCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.description(description.clone())
|
||||
.image(image.clone())
|
||||
.category_id(category_id)
|
||||
.adding_by(adding_by)
|
||||
.quantity(quantity.clone())
|
||||
.adding_by(adding_by)
|
||||
.sku_able(sku_able)
|
||||
.product_id(UUID)
|
||||
.price(price.clone())
|
||||
// .customizations(customizations.clone())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let cmd = cmd.validate().unwrap();
|
||||
|
||||
assert_eq!(cmd.name(), name);
|
||||
assert_eq!(cmd.description(), &description);
|
||||
assert_eq!(cmd.adding_by(), &adding_by);
|
||||
|
|
@ -231,8 +238,7 @@ pub mod tests {
|
|||
|
||||
let quantity = Quantity::default();
|
||||
|
||||
// AddProductCommandError::NameIsEmpty
|
||||
assert!(AddProductCommandBuilder::default()
|
||||
let cmd = UnvalidatedAddProductCommandBuilder::default()
|
||||
.name("".into())
|
||||
.description(description.clone())
|
||||
.image(image.clone())
|
||||
|
|
@ -240,9 +246,11 @@ pub mod tests {
|
|||
.adding_by(adding_by)
|
||||
.quantity(quantity)
|
||||
.sku_able(sku_able)
|
||||
.product_id(UUID)
|
||||
.price(price.clone())
|
||||
.build()
|
||||
.is_err());
|
||||
.unwrap();
|
||||
|
||||
// AddProductCommandError::NameIsEmpty
|
||||
assert_eq!(cmd.validate(), Err(AddProductCommandError::NameIsEmpty))
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@
|
|||
//
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
use derive_builder::Builder;
|
||||
use derive_getters::Getters;
|
||||
use derive_more::{Display, Error};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
|
@ -13,52 +12,46 @@ pub enum AddStoreCommandError {
|
|||
NameIsEmpty,
|
||||
}
|
||||
|
||||
#[derive(
|
||||
Clone, Builder, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters,
|
||||
)]
|
||||
#[builder(build_fn(validate = "Self::validate"))]
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
||||
pub struct AddStoreCommand {
|
||||
#[builder(setter(custom))]
|
||||
name: String,
|
||||
#[builder(setter(custom))]
|
||||
address: Option<String>,
|
||||
store_id: Uuid,
|
||||
owner: Uuid,
|
||||
}
|
||||
|
||||
impl AddStoreCommandBuilder {
|
||||
pub fn address(&mut self, address: Option<String>) -> &mut Self {
|
||||
self.address = if let Some(address) = address {
|
||||
impl AddStoreCommand {
|
||||
pub fn new(
|
||||
name: String,
|
||||
address: Option<String>,
|
||||
owner: Uuid,
|
||||
) -> Result<Self, AddStoreCommandError> {
|
||||
let address: Option<String> = if let Some(address) = address {
|
||||
let address = address.trim();
|
||||
if address.is_empty() {
|
||||
Some(None)
|
||||
None
|
||||
} else {
|
||||
Some(Some(address.to_owned()))
|
||||
Some(address.to_owned())
|
||||
}
|
||||
} else {
|
||||
Some(None)
|
||||
None
|
||||
};
|
||||
self
|
||||
}
|
||||
|
||||
pub fn name(&mut self, name: String) -> &mut Self {
|
||||
self.name = Some(name.trim().to_owned());
|
||||
self
|
||||
}
|
||||
|
||||
fn validate(&self) -> Result<(), String> {
|
||||
let name = self.name.as_ref().unwrap().trim().to_owned();
|
||||
let name = name.trim().to_owned();
|
||||
if name.is_empty() {
|
||||
return Err(AddStoreCommandError::NameIsEmpty.to_string());
|
||||
return Err(AddStoreCommandError::NameIsEmpty);
|
||||
}
|
||||
Ok(())
|
||||
|
||||
Ok(Self {
|
||||
name,
|
||||
address,
|
||||
owner,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::tests::bdd::*;
|
||||
use crate::utils::uuid::tests::*;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
|
||||
use super::*;
|
||||
|
||||
|
|
@ -69,41 +62,21 @@ mod tests {
|
|||
let owner = UUID;
|
||||
|
||||
// address = None
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(None)
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let cmd = AddStoreCommand::new(name.into(), None, owner).unwrap();
|
||||
assert_eq!(cmd.name(), name);
|
||||
assert_eq!(cmd.address(), &None);
|
||||
assert_eq!(cmd.owner(), &owner);
|
||||
assert_eq!(*cmd.store_id(), UUID);
|
||||
|
||||
// address = Some
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(Some(address.into()))
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let cmd = AddStoreCommand::new(name.into(), Some(address.into()), owner).unwrap();
|
||||
assert_eq!(cmd.name(), name);
|
||||
assert_eq!(cmd.address(), &Some(address.to_owned()));
|
||||
assert_eq!(cmd.owner(), &owner);
|
||||
assert_eq!(*cmd.store_id(), UUID);
|
||||
|
||||
// AddStoreCommandError::NameIsEmpty
|
||||
|
||||
assert!(AddStoreCommandBuilder::default()
|
||||
.name("".into())
|
||||
.address(Some(address.into()))
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.is_err())
|
||||
assert_eq!(
|
||||
AddStoreCommand::new("".into(), Some(address.into()), owner),
|
||||
Err(AddStoreCommandError::NameIsEmpty)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -81,8 +81,8 @@ mod aggregate_tests {
|
|||
use std::sync::Arc;
|
||||
|
||||
use cqrs_es::test::TestFramework;
|
||||
use tests::get_add_category_cmd;
|
||||
use update_category_service::tests::mock_update_category_service;
|
||||
use uuid::Uuid;
|
||||
|
||||
use super::*;
|
||||
use crate::ordering::{
|
||||
|
|
@ -95,19 +95,27 @@ mod aggregate_tests {
|
|||
},
|
||||
};
|
||||
use crate::tests::bdd::*;
|
||||
use crate::utils::uuid::tests::*;
|
||||
|
||||
type CategoryTestFramework = TestFramework<Category>;
|
||||
|
||||
#[test]
|
||||
fn test_create_category() {
|
||||
let cmd = get_add_category_cmd();
|
||||
let name = "category_name";
|
||||
let description = Some("category_description".to_string());
|
||||
let adding_by = UUID;
|
||||
let store_id = Uuid::new_v4();
|
||||
let category_id = UUID;
|
||||
|
||||
let cmd =
|
||||
AddCategoryCommand::new(name.into(), description.clone(), store_id, adding_by).unwrap();
|
||||
|
||||
let expected = CategoryAddedEventBuilder::default()
|
||||
.name(cmd.name().into())
|
||||
.description(cmd.description().as_ref().map(|s| s.to_string()))
|
||||
.added_by_user(*cmd.adding_by())
|
||||
.store_id(*cmd.store_id())
|
||||
.category_id(*cmd.category_id())
|
||||
.category_id(category_id)
|
||||
.build()
|
||||
.unwrap();
|
||||
let expected = OrderingEvent::CategoryAdded(expected);
|
||||
|
|
|
|||
|
|
@ -20,18 +20,12 @@ pub struct KotAddedEvent {
|
|||
|
||||
#[cfg(test)]
|
||||
pub mod tests {
|
||||
use crate::ordering::domain::{add_kot_command::AddKotCommand, kot_aggregate::*};
|
||||
use crate::ordering::domain::add_kot_command::AddKotCommand;
|
||||
|
||||
use super::*;
|
||||
|
||||
pub fn get_added_kot_event_from_command(cmd: &AddKotCommand) -> KotAddedEvent {
|
||||
let kot = KotBuilder::default()
|
||||
.created_time(cmd.created_time().clone())
|
||||
.order_id(*cmd.order_id())
|
||||
.kot_id(*cmd.kot_id())
|
||||
.deleted(false)
|
||||
.build()
|
||||
.unwrap();
|
||||
let kot = Kot::get_kot();
|
||||
|
||||
KotAddedEventBuilder::default()
|
||||
.added_by_user(cmd.adding_by().clone())
|
||||
|
|
|
|||
|
|
@ -21,11 +21,11 @@ use crate::ordering::{
|
|||
pub struct Order {
|
||||
#[builder(default = "OffsetDateTime::now_utc()")]
|
||||
created_time: OffsetDateTime,
|
||||
store_id: Uuid,
|
||||
// kot_ids: Vec<Kot>,
|
||||
order_id: Uuid,
|
||||
#[builder(default = "false")]
|
||||
deleted: bool,
|
||||
customer_name: Option<String>,
|
||||
customer_name: String,
|
||||
}
|
||||
|
||||
impl Default for Order {
|
||||
|
|
@ -33,9 +33,8 @@ impl Default for Order {
|
|||
Self {
|
||||
created_time: OffsetDateTime::now_utc(),
|
||||
order_id: Default::default(),
|
||||
store_id: Default::default(),
|
||||
deleted: false,
|
||||
customer_name: None,
|
||||
customer_name: Default::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -52,9 +51,8 @@ mod tests {
|
|||
|
||||
OrderBuilder::default()
|
||||
.created_time(cmd.created_time().clone())
|
||||
.customer_name(Some("test_product".into()))
|
||||
.order_id(*cmd.order_id())
|
||||
.store_id(*cmd.store_id())
|
||||
.customer_name("test_product".into())
|
||||
.order_id(UUID)
|
||||
.build()
|
||||
.unwrap()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,9 +27,8 @@ pub mod tests {
|
|||
pub fn get_deleted_order_event_from_command(cmd: &DeleteOrderCommand) -> OrderDeletedEvent {
|
||||
let deleted_order = OrderBuilder::default()
|
||||
.created_time(cmd.order().created_time().clone())
|
||||
.customer_name(cmd.order().customer_name().clone())
|
||||
.customer_name(cmd.order().customer_name().into())
|
||||
.order_id(*cmd.order().order_id())
|
||||
.store_id(*cmd.order().store_id())
|
||||
.deleted(true)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
|
|
|||
|
|
@ -28,9 +28,8 @@ pub mod tests {
|
|||
pub fn get_updated_order_event_from_command(cmd: &UpdateOrderCommand) -> OrderUpdatedEvent {
|
||||
let new_order = OrderBuilder::default()
|
||||
.created_time(cmd.created_time().clone())
|
||||
.customer_name(cmd.customer_name().clone())
|
||||
.customer_name(cmd.customer_name().into())
|
||||
.order_id(*cmd.old_order().order_id())
|
||||
.store_id(*cmd.old_order().store_id())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -113,13 +113,7 @@ mod tests {
|
|||
.unwrap();
|
||||
let expected = OrderingEvent::StoreAdded(expected);
|
||||
|
||||
let cmd = AddStoreCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.address(address.clone())
|
||||
.owner(owner)
|
||||
.store_id(UUID)
|
||||
.build()
|
||||
.unwrap();
|
||||
let cmd = AddStoreCommand::new(name.into(), address.clone(), owner).unwrap();
|
||||
|
||||
let mut services = MockOrderingServicesInterface::new();
|
||||
services
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ use time::OffsetDateTime;
|
|||
use uuid::Uuid;
|
||||
|
||||
use super::order_aggregate::*;
|
||||
use crate::utils::string::empty_string_err;
|
||||
|
||||
#[derive(Debug, Error, Display, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub enum UpdateOrderCommandError {
|
||||
|
|
@ -19,33 +20,39 @@ pub enum UpdateOrderCommandError {
|
|||
#[derive(
|
||||
Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters, Builder,
|
||||
)]
|
||||
pub struct UpdateOrderCommand {
|
||||
pub struct UnvalidatedUpdateOrderCommand {
|
||||
adding_by: Uuid,
|
||||
|
||||
#[builder(default = "OffsetDateTime::now_utc()")]
|
||||
created_time: OffsetDateTime,
|
||||
#[builder(setter(custom))]
|
||||
customer_name: Option<String>,
|
||||
|
||||
customer_name: String,
|
||||
old_order: Order,
|
||||
}
|
||||
|
||||
impl UpdateOrderCommandBuilder {
|
||||
pub fn customer_name(&mut self, customer_name: Option<String>) -> &mut Self {
|
||||
self.customer_name = if let Some(customer_name) = customer_name {
|
||||
let customer_name = customer_name.trim();
|
||||
if customer_name.is_empty() {
|
||||
Some(None)
|
||||
} else {
|
||||
Some(Some(customer_name.to_string()))
|
||||
}
|
||||
} else {
|
||||
Some(None)
|
||||
};
|
||||
self
|
||||
impl UnvalidatedUpdateOrderCommand {
|
||||
pub fn validate(self) -> Result<UpdateOrderCommand, UpdateOrderCommandError> {
|
||||
let customer_name = empty_string_err(
|
||||
self.customer_name,
|
||||
UpdateOrderCommandError::CustomerNameIsEmpty,
|
||||
)?;
|
||||
|
||||
Ok(UpdateOrderCommand {
|
||||
created_time: self.created_time,
|
||||
customer_name,
|
||||
adding_by: self.adding_by,
|
||||
old_order: self.old_order,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Ord, PartialOrd, Getters)]
|
||||
pub struct UpdateOrderCommand {
|
||||
created_time: OffsetDateTime,
|
||||
customer_name: String,
|
||||
adding_by: Uuid,
|
||||
old_order: Order,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use time::macros::datetime;
|
||||
|
|
@ -59,13 +66,15 @@ mod tests {
|
|||
let customer_name = "foo-new-name";
|
||||
let adding_by = UUID;
|
||||
|
||||
UpdateOrderCommandBuilder::default()
|
||||
.customer_name(Some(customer_name.into()))
|
||||
UnvalidatedUpdateOrderCommandBuilder::default()
|
||||
.customer_name(customer_name.into())
|
||||
.adding_by(adding_by)
|
||||
.created_time(datetime!(1970-01-01 0:00 UTC))
|
||||
.old_order(Order::default())
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -75,15 +84,17 @@ mod tests {
|
|||
let adding_by = UUID;
|
||||
let old_order = Order::default();
|
||||
|
||||
let cmd = UpdateOrderCommandBuilder::default()
|
||||
.customer_name(Some(customer_name.into()))
|
||||
let cmd = UnvalidatedUpdateOrderCommandBuilder::default()
|
||||
.customer_name(customer_name.into())
|
||||
.adding_by(adding_by)
|
||||
.old_order(old_order.clone())
|
||||
.build()
|
||||
.unwrap()
|
||||
.validate()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(*cmd.adding_by(), adding_by);
|
||||
assert_eq!(cmd.customer_name().as_ref().unwrap(), customer_name);
|
||||
assert_eq!(cmd.customer_name(), customer_name);
|
||||
assert_eq!(cmd.old_order(), &old_order);
|
||||
}
|
||||
|
||||
|
|
@ -92,13 +103,15 @@ mod tests {
|
|||
let customer_name = "";
|
||||
let adding_by = UUID;
|
||||
|
||||
let cmd = UpdateOrderCommandBuilder::default()
|
||||
.customer_name(Some(customer_name.into()))
|
||||
assert_eq!(
|
||||
UnvalidatedUpdateOrderCommandBuilder::default()
|
||||
.customer_name(customer_name.into())
|
||||
.adding_by(adding_by)
|
||||
.old_order(Order::default())
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
assert!(cmd.customer_name().is_none());
|
||||
.unwrap()
|
||||
.validate(),
|
||||
Err(UpdateOrderCommandError::CustomerNameIsEmpty)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -95,55 +95,6 @@ pub mod tests {
|
|||
use crate::types::quantity::*;
|
||||
use crate::utils::uuid::tests::UUID;
|
||||
|
||||
pub fn get_command_with_product(product: Product) -> UpdateProductCommand {
|
||||
let name = "foobaaar";
|
||||
let adding_by = UUID;
|
||||
let category_id = UUID;
|
||||
let sku_able = false;
|
||||
let image = Some("imageeee".to_string());
|
||||
let description = Some("descriptionnnn".to_string());
|
||||
|
||||
let price = PriceBuilder::default()
|
||||
.minor(0)
|
||||
.major(100)
|
||||
.currency(Currency::INR)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let quantity = QuantityBuilder::default()
|
||||
.minor(
|
||||
QuantityPartBuilder::default()
|
||||
.number(0)
|
||||
.unit(QuantityUnit::DiscreteNumber)
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
.major(
|
||||
QuantityPartBuilder::default()
|
||||
.number(1)
|
||||
.unit(QuantityUnit::DiscreteNumber)
|
||||
.build()
|
||||
.unwrap(),
|
||||
)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let cmd = UnvalidatedUpdateProductCommandBuilder::default()
|
||||
.name(name.into())
|
||||
.description(description.clone())
|
||||
.image(image.clone())
|
||||
.category_id(category_id.clone())
|
||||
.adding_by(adding_by.clone())
|
||||
.quantity(quantity)
|
||||
.sku_able(sku_able)
|
||||
.price(price.clone())
|
||||
.old_product(product)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
cmd.validate().unwrap()
|
||||
}
|
||||
|
||||
pub fn get_command() -> UpdateProductCommand {
|
||||
let name = "foo";
|
||||
let adding_by = UUID;
|
||||
|
|
|
|||
Loading…
Reference in a new issue