lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

profile_complete_edit.rs (4078B)


      1 use radroots_event::{
      2     profile::edit::{ProfileEdit, ProfileFieldChange},
      3     wire::Nip01EventWire,
      4 };
      5 use radroots_event_codec::{
      6     admission::profile::verify_and_admit_profile_event, authoring::AuthoredEventPlan,
      7 };
      8 use radroots_storage::{
      9     Error,
     10     authored::DurableAuthoredPlan,
     11     authored_draft::{
     12         AuthoredDraft, AuthoredDraftId, AuthoredDraftStage, AuthoredDraftStore,
     13         DraftAppendDisposition,
     14     },
     15     event::SourceGeneration,
     16     memory::MemoryStorage,
     17 };
     18 use radroots_storage_sqlite::{OpenMode, OpenOptions, Paths, SqliteStorage};
     19 
     20 // Exact canonical profile_admit_tagless_tolerant_001 vector, packaged locally.
     21 fn edit_draft() -> (AuthoredEventPlan, AuthoredDraft) {
     22     let baseline = verify_and_admit_profile_event(
     23         Nip01EventWire::parse_json(include_str!("fixtures/profile_edit_baseline.v1.json"))
     24             .unwrap()
     25             .into_envelope()
     26             .unwrap(),
     27     )
     28     .unwrap();
     29     let plan = AuthoredEventPlan::from_profile_edit(
     30         &baseline,
     31         &baseline,
     32         &ProfileEdit {
     33             display_name: ProfileFieldChange::Set("Updated farm".into()),
     34             ..Default::default()
     35         },
     36         baseline.event().created_at_u64() + 1,
     37         baseline.event().author().to_hex(),
     38     )
     39     .unwrap();
     40     let durable = DurableAuthoredPlan::from_plan(&plan).unwrap();
     41     let draft = AuthoredDraft::initial(
     42         AuthoredDraftId::new([41; 16]).unwrap(),
     43         *plan.author().as_bytes(),
     44         "radroots.authored_event_plan.v1",
     45         durable.wire_json().to_vec(),
     46         AuthoredDraftStage::Draft,
     47         None,
     48         100,
     49     )
     50     .unwrap();
     51     (plan, draft)
     52 }
     53 
     54 async fn exercise(store: &dyn AuthoredDraftStore, draft: &AuthoredDraft) {
     55     store
     56         .append_authored_draft(draft.clone(), None)
     57         .await
     58         .unwrap();
     59     assert_eq!(
     60         store
     61             .append_authored_draft(draft.clone(), None)
     62             .await
     63             .unwrap()
     64             .disposition(),
     65         DraftAppendDisposition::Replay
     66     );
     67     let conflicting = AuthoredDraft::initial(
     68         draft.draft_id(),
     69         *draft.author(),
     70         draft.payload_schema(),
     71         b"conflicting".to_vec(),
     72         AuthoredDraftStage::Draft,
     73         None,
     74         100,
     75     )
     76     .unwrap();
     77     assert_eq!(
     78         store.append_authored_draft(conflicting, None).await,
     79         Err(Error::DraftRevisionConflict)
     80     );
     81     assert_eq!(
     82         store
     83             .authored_draft_head(draft.draft_id())
     84             .await
     85             .unwrap()
     86             .unwrap(),
     87         *draft
     88     );
     89 }
     90 
     91 #[tokio::test]
     92 async fn profile_complete_edit_sqlite_and_memory_durable_replay_and_readonly_reopen_preserve_metadata()
     93  {
     94     let (plan, draft) = edit_draft();
     95     let directory = tempfile::tempdir().unwrap();
     96     let paths = Paths::from_directory(directory.path()).unwrap();
     97     let store = SqliteStorage::open(
     98         OpenOptions::new(paths.clone(), OpenMode::Create)
     99             .with_source_generation(SourceGeneration::new([41; 32]).unwrap(), 100)
    100             .unwrap(),
    101     )
    102     .await
    103     .unwrap();
    104     exercise(&MemoryStorage::default(), &draft).await;
    105     exercise(&store, &draft).await;
    106     store.close().await.unwrap();
    107     let reader = SqliteStorage::open(OpenOptions::new(paths, OpenMode::ReadOnly))
    108         .await
    109         .unwrap();
    110     let stored = reader
    111         .authored_draft_head(draft.draft_id())
    112         .await
    113         .unwrap()
    114         .unwrap();
    115     assert_eq!(stored, draft);
    116     let restored = DurableAuthoredPlan::reconstruct(stored.payload().to_vec()).unwrap();
    117     assert_eq!(restored.decode().unwrap().plan(), &plan);
    118     assert_eq!(
    119         reader.append_authored_draft(draft.clone(), None).await,
    120         Err(Error::BackendUnavailable)
    121     );
    122     let fields: serde_json::Value = serde_json::from_str(plan.body().content()).unwrap();
    123     assert_eq!(fields["display_name"], "Updated farm");
    124     assert_eq!(fields["picture"], 42);
    125     assert_eq!(fields["website"], "https://mossstreet.example");
    126     assert_eq!(fields["bot"], false);
    127     reader.close().await.unwrap();
    128 }