more selling tests!

tests/test_shops.rs

@@ -725,7 +725,7 @@ async fn test_player_sells_rare_item() {
 }
 
 #[async_std::test]
-async fn test_player_sells_photon_drops() {
+async fn test_player_sells_partial_photon_drop_stack() {
     let mut entity_gateway = InMemoryGateway::default();
 
     let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@@ -769,4 +769,400 @@ async fn test_player_sells_photon_drops() {
     let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
     let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
     assert_eq!(c1.meseta, 3000);
-}
+}
+
+#[async_std::test]
+async fn test_player_sells_basic_frame() {
+    let mut entity_gateway = InMemoryGateway::default();
+
+    let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
+
+    let mut p1_inv = Vec::new();
+
+    p1_inv.push(entity_gateway.create_item(
+        item::NewItemEntity {
+            item: item::ItemDetail::Armor(
+                item::armor::Armor {
+                    armor: item::armor::ArmorType::Frame,
+                    dfp: 0,
+                    evp: 0,
+                    slots: 0,
+                }
+            ),
+            location: item::ItemLocation::Inventory {
+                character_id: char1.id,
+            }
+        }).await.unwrap());
+
+    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
+
+    let mut ship = Box::new(ShipServerState::builder()
+        .gateway(entity_gateway.clone())
+        .build());
+
+    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
+    join_lobby(&mut ship, ClientId(1)).await;
+    create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
+
+    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSoldItem(PlayerSoldItem {
+        client: 0,
+        target: 0,
+        item_id: 0x10000,
+        amount: 1,
+    })))).await.unwrap().for_each(drop);
+
+    let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
+    let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
+    assert_eq!(c1.meseta, 24);
+}
+
+#[async_std::test]
+async fn test_player_sells_max_frame() {
+    let mut entity_gateway = InMemoryGateway::default();
+
+    let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
+
+    let mut p1_inv = Vec::new();
+
+    p1_inv.push(entity_gateway.create_item(
+        item::NewItemEntity {
+            item: item::ItemDetail::Armor(
+                item::armor::Armor {
+                    armor: item::armor::ArmorType::Frame,
+                    dfp: 2,
+                    evp: 2,
+                    slots: 4,
+                }
+            ),
+            location: item::ItemLocation::Inventory {
+                character_id: char1.id,
+            }
+        }).await.unwrap());
+
+    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
+
+    let mut ship = Box::new(ShipServerState::builder()
+        .gateway(entity_gateway.clone())
+        .build());
+
+    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
+    join_lobby(&mut ship, ClientId(1)).await;
+    create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
+
+    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSoldItem(PlayerSoldItem {
+        client: 0,
+        target: 0,
+        item_id: 0x10000,
+        amount: 1,
+    })))).await.unwrap().for_each(drop);
+
+    let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
+    let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
+    assert_eq!(c1.meseta, 74);
+}
+
+#[async_std::test]
+async fn test_player_sells_basic_barrier() {
+    let mut entity_gateway = InMemoryGateway::default();
+
+    let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
+
+    let mut p1_inv = Vec::new();
+
+    p1_inv.push(entity_gateway.create_item(
+        item::NewItemEntity {
+            item: item::ItemDetail::Shield(
+                item::shield::Shield {
+                    shield: item::shield::ShieldType::Barrier,
+                    dfp: 0,
+                    evp: 0,
+                }
+            ),
+            location: item::ItemLocation::Inventory {
+                character_id: char1.id,
+            }
+        }).await.unwrap());
+
+    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
+
+    let mut ship = Box::new(ShipServerState::builder()
+        .gateway(entity_gateway.clone())
+        .build());
+
+    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
+    join_lobby(&mut ship, ClientId(1)).await;
+    create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
+
+    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSoldItem(PlayerSoldItem {
+        client: 0,
+        target: 0,
+        item_id: 0x10000,
+        amount: 1,
+    })))).await.unwrap().for_each(drop);
+
+    let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
+    let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
+    assert_eq!(c1.meseta, 69);
+}
+
+#[async_std::test]
+async fn test_player_sells_max_barrier() {
+    let mut entity_gateway = InMemoryGateway::default();
+
+    let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
+
+    let mut p1_inv = Vec::new();
+
+    p1_inv.push(entity_gateway.create_item(
+        item::NewItemEntity {
+            item: item::ItemDetail::Shield(
+                item::shield::Shield {
+                    shield: item::shield::ShieldType::Barrier,
+                    dfp: 5,
+                    evp: 5,
+                }
+            ),
+            location: item::ItemLocation::Inventory {
+                character_id: char1.id,
+            }
+        }).await.unwrap());
+
+    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
+
+    let mut ship = Box::new(ShipServerState::builder()
+        .gateway(entity_gateway.clone())
+        .build());
+
+    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
+    join_lobby(&mut ship, ClientId(1)).await;
+    create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
+
+    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSoldItem(PlayerSoldItem {
+        client: 0,
+        target: 0,
+        item_id: 0x10000,
+        amount: 1,
+    })))).await.unwrap().for_each(drop);
+
+    let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
+    let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
+    assert_eq!(c1.meseta, 122);
+}
+
+#[async_std::test]
+async fn test_player_sells_1_star_minusminus_unit() {
+    let mut entity_gateway = InMemoryGateway::default();
+
+    let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
+
+    let mut p1_inv = Vec::new();
+
+    p1_inv.push(entity_gateway.create_item(
+        item::NewItemEntity {
+            item: item::ItemDetail::Unit(
+                item::unit::Unit {
+                    unit: item::unit::UnitType::PriestMind,
+                    modifier: Some(item::unit::UnitModifier::MinusMinus),
+                }
+            ),
+            location: item::ItemLocation::Inventory {
+                character_id: char1.id,
+            }
+        }).await.unwrap());
+
+    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
+
+    let mut ship = Box::new(ShipServerState::builder()
+        .gateway(entity_gateway.clone())
+        .build());
+
+    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
+    join_lobby(&mut ship, ClientId(1)).await;
+    create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
+
+    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSoldItem(PlayerSoldItem {
+        client: 0,
+        target: 0,
+        item_id: 0x10000,
+        amount: 1,
+    })))).await.unwrap().for_each(drop);
+
+    let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
+    let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
+    assert_eq!(c1.meseta, 125);
+}
+
+#[async_std::test]
+async fn test_player_sells_5_star_plusplus_unit() {
+    let mut entity_gateway = InMemoryGateway::default();
+
+    let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
+
+    let mut p1_inv = Vec::new();
+
+    p1_inv.push(entity_gateway.create_item(
+        item::NewItemEntity {
+            item: item::ItemDetail::Unit(
+                item::unit::Unit {
+                    unit: item::unit::UnitType::GeneralHp,
+                    modifier: Some(item::unit::UnitModifier::PlusPlus),
+                }
+            ),
+            location: item::ItemLocation::Inventory {
+                character_id: char1.id,
+            }
+        }).await.unwrap());
+
+    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
+
+    let mut ship = Box::new(ShipServerState::builder()
+        .gateway(entity_gateway.clone())
+        .build());
+
+    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
+    join_lobby(&mut ship, ClientId(1)).await;
+    create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
+
+    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSoldItem(PlayerSoldItem {
+        client: 0,
+        target: 0,
+        item_id: 0x10000,
+        amount: 1,
+    })))).await.unwrap().for_each(drop);
+
+    let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
+    let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
+    assert_eq!(c1.meseta, 625);
+}
+
+#[async_std::test]
+async fn test_player_sells_rare_frame() {
+    let mut entity_gateway = InMemoryGateway::default();
+
+    let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
+
+    let mut p1_inv = Vec::new();
+
+    p1_inv.push(entity_gateway.create_item(
+        item::NewItemEntity {
+            item: item::ItemDetail::Armor(
+                item::armor::Armor {
+                    armor: item::armor::ArmorType::StinkFrame,
+                    dfp: 10,
+                    evp: 20,
+                    slots: 3,
+                }
+            ),
+            location: item::ItemLocation::Inventory {
+                character_id: char1.id,
+            }
+        }).await.unwrap());
+
+    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
+
+    let mut ship = Box::new(ShipServerState::builder()
+        .gateway(entity_gateway.clone())
+        .build());
+
+    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
+    join_lobby(&mut ship, ClientId(1)).await;
+    create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
+
+    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSoldItem(PlayerSoldItem {
+        client: 0,
+        target: 0,
+        item_id: 0x10000,
+        amount: 1,
+    })))).await.unwrap().for_each(drop);
+
+    let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
+    let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
+    assert_eq!(c1.meseta, 10);
+}
+
+#[async_std::test]
+async fn test_player_sells_rare_barrier() {
+    let mut entity_gateway = InMemoryGateway::default();
+
+    let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
+
+    let mut p1_inv = Vec::new();
+
+    p1_inv.push(entity_gateway.create_item(
+        item::NewItemEntity {
+            item: item::ItemDetail::Shield(
+                item::shield::Shield {
+                    shield: item::shield::ShieldType::RedRing,
+                    dfp: 10,
+                    evp: 20,
+                }
+            ),
+            location: item::ItemLocation::Inventory {
+                character_id: char1.id,
+            }
+        }).await.unwrap());
+
+    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
+
+    let mut ship = Box::new(ShipServerState::builder()
+        .gateway(entity_gateway.clone())
+        .build());
+
+    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
+    join_lobby(&mut ship, ClientId(1)).await;
+    create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
+
+    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSoldItem(PlayerSoldItem {
+        client: 0,
+        target: 0,
+        item_id: 0x10000,
+        amount: 1,
+    })))).await.unwrap().for_each(drop);
+
+    let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
+    let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
+    assert_eq!(c1.meseta, 10);
+}
+
+#[async_std::test]
+async fn test_player_sells_rare_unit() {
+    let mut entity_gateway = InMemoryGateway::default();
+
+    let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
+
+    let mut p1_inv = Vec::new();
+
+    p1_inv.push(entity_gateway.create_item(
+        item::NewItemEntity {
+            item: item::ItemDetail::Unit(
+                item::unit::Unit {
+                    unit: item::unit::UnitType::V101,
+                    modifier: None,
+                }
+            ),
+            location: item::ItemLocation::Inventory {
+                character_id: char1.id,
+            }
+        }).await.unwrap());
+
+    entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
+
+    let mut ship = Box::new(ShipServerState::builder()
+        .gateway(entity_gateway.clone())
+        .build());
+
+    log_in_char(&mut ship, ClientId(1), "a1", "a").await;
+    join_lobby(&mut ship, ClientId(1)).await;
+    create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
+
+    ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerSoldItem(PlayerSoldItem {
+        client: 0,
+        target: 0,
+        item_id: 0x10000,
+        amount: 1,
+    })))).await.unwrap().for_each(drop);
+
+    let characters1 = entity_gateway.get_characters_by_user(&user1).await.unwrap();
+    let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
+    assert_eq!(c1.meseta, 10);
+}