Skip to content

Bring projects, wikis, and teams together with AI. AppFlowy is the AI collaborative workspace where you achieve more without losing control of your data. The leading open source Notion alternative.

10.5 KB
Raw Blame
use collab_folder::ViewLayout;

use event_integration_test::event_builder::EventBuilder;
use event_integration_test::EventIntegrationTest;
use flowy_folder::entities::icon::{UpdateViewIconPayloadPB, ViewIconPB};
use flowy_folder::entities::*;
use flowy_folder::event_map::FolderEvent::*;

pub enum FolderScript {
  #[allow(dead_code)]
  CreateWorkspace {
    name: String,
    desc: String,
  },
  #[allow(dead_code)]
  AssertWorkspace(WorkspacePB),
  #[allow(dead_code)]
  ReadWorkspace(String),
  CreateParentView {
    name: String,
    desc: String,
  },
  AssertParentView(ViewPB),
  ReloadParentView(String),
  UpdateParentView {
    name: Option<String>,
    desc: Option<String>,
    is_favorite: Option<bool>,
  },
  DeleteParentView,

  // View
  CreateView {
    name: String,
    desc: String,
    layout: ViewLayout,
  },
  AssertView(ViewPB),
  ReadView(String),
  UpdateView {
    name: Option<String>,
    desc: Option<String>,
    is_favorite: Option<bool>,
  },
  UpdateViewIcon {
    icon: Option<ViewIconPB>,
  },
  DeleteView,
  DeleteViews(Vec<String>),
  MoveView {
    view_id: String,
    new_parent_id: String,
    prev_view_id: Option<String>,
  },

  // Trash
  RestoreAppFromTrash,
  RestoreViewFromTrash,
  ReadTrash,
  DeleteAllTrash,
  ToggleFavorite,
  ReadFavorites,
}

pub struct FolderTest {
  pub sdk: EventIntegrationTest,
  pub workspace: WorkspacePB,
  pub parent_view: ViewPB,
  pub child_view: ViewPB,
  pub trash: Vec<TrashPB>,
  pub favorites: Vec<ViewPB>,
}

impl FolderTest {
  pub async fn new() -> Self {
    let sdk = EventIntegrationTest::new().await;
    let _ = sdk.init_anon_user().await;
    let workspace = sdk.folder_manager.get_current_workspace().await.unwrap();
    let parent_view = create_view(
      &sdk,
      &workspace.id,
      "first level view",
      "",
      ViewLayout::Document,
    )
    .await;
    let view = create_view(
      &sdk,
      &parent_view.id,
      "second level view",
      "",
      ViewLayout::Document,
    )
    .await;
    Self {
      sdk,
      workspace,
      parent_view,
      child_view: view,
      trash: vec![],
      favorites: vec![],
    }
  }

  pub async fn run_scripts(&mut self, scripts: Vec<FolderScript>) {
    for script in scripts {
      self.run_script(script).await;
    }
  }

  pub async fn run_script(&mut self, script: FolderScript) {
    let sdk = &self.sdk;
    match script {
      FolderScript::CreateWorkspace { name, desc } => {
        let workspace = create_workspace(sdk, &name, &desc).await;
        self.workspace = workspace;
      },
      FolderScript::AssertWorkspace(workspace) => {
        assert_eq!(self.workspace, workspace, "Workspace not equal");
      },
      FolderScript::ReadWorkspace(workspace_id) => {
        let workspace = read_workspace(sdk, workspace_id).await;
        self.workspace = workspace;
      },
      FolderScript::CreateParentView { name, desc } => {
        let app = create_view(sdk, &self.workspace.id, &name, &desc, ViewLayout::Document).await;
        self.parent_view = app;
      },
      FolderScript::AssertParentView(view) => {
        assert_eq!(self.parent_view.id, view.id, "view id not equal");
        assert_eq!(self.parent_view.name, view.name, "view name not equal");
        assert_eq!(
          self.parent_view.is_favorite, view.is_favorite,
          "view name not equal"
        );
      },
      FolderScript::ReloadParentView(parent_view_id) => {
        let parent_view = read_view(sdk, &parent_view_id).await;
        self.parent_view = parent_view;
      },
      FolderScript::UpdateParentView {
        name,
        desc,
        is_favorite,
      } => {
        update_view(sdk, &self.parent_view.id, name, desc, is_favorite).await;
      },
      FolderScript::DeleteParentView => {
        delete_view(sdk, vec![self.parent_view.id.clone()]).await;
      },
      FolderScript::CreateView { name, desc, layout } => {
        let view = create_view(sdk, &self.parent_view.id, &name, &desc, layout).await;
        self.child_view = view;
      },
      FolderScript::MoveView {
        view_id,
        new_parent_id,
        prev_view_id,
      } => {
        move_view(sdk, view_id, new_parent_id, prev_view_id).await;
      },
      FolderScript::AssertView(view) => {
        assert_eq!(self.child_view, view, "View not equal");
      },
      FolderScript::ReadView(view_id) => {
        let mut view = read_view(sdk, &view_id).await;
        // Ignore the last edited time
        view.last_edited = 0;
        self.child_view = view;
      },
      FolderScript::UpdateView {
        name,
        desc,
        is_favorite,
      } => {
        update_view(sdk, &self.child_view.id, name, desc, is_favorite).await;
      },
      FolderScript::UpdateViewIcon { icon } => {
        update_view_icon(sdk, &self.child_view.id, icon).await;
      },
      FolderScript::DeleteView => {
        delete_view(sdk, vec![self.child_view.id.clone()]).await;
      },
      FolderScript::DeleteViews(view_ids) => {
        delete_view(sdk, view_ids).await;
      },
      FolderScript::RestoreAppFromTrash => {
        restore_app_from_trash(sdk, &self.parent_view.id).await;
      },
      FolderScript::RestoreViewFromTrash => {
        restore_view_from_trash(sdk, &self.child_view.id).await;
      },
      FolderScript::ReadTrash => {
        let trash = read_trash(sdk).await;
        self.trash = trash.items;
      },
      FolderScript::DeleteAllTrash => {
        delete_all_trash(sdk).await;
        self.trash = vec![];
      },
      FolderScript::ToggleFavorite => {
        toggle_favorites(sdk, vec![self.child_view.id.clone()]).await;
      },
      FolderScript::ReadFavorites => {
        let favorites = read_favorites(sdk).await;
        self.favorites = favorites.items.iter().map(|x| x.item.clone()).collect();
      },
    }
  }

  //   pub async fn duplicate_view(&self, view_id: &str) {
  //     let payload = DuplicateViewPayloadPB {
  //       view_id: view_id.to_string(),
  //       open_after_duplicate: false,
  //       include_children: false,
  //       parent_view_id: None,
  //       suffix: None,
  //       sync_after_create: false,
  //     };
  //     EventBuilder::new(self.sdk.clone())
  //       .event(DuplicateView)
  //       .payload(payload)
  //       .async_send()
  //       .await;
  //   }
}
pub async fn create_workspace(sdk: &EventIntegrationTest, name: &str, desc: &str) -> WorkspacePB {
  let request = CreateWorkspacePayloadPB {
    name: name.to_owned(),
    desc: desc.to_owned(),
  };

  EventBuilder::new(sdk.clone())
    .event(CreateFolderWorkspace)
    .payload(request)
    .async_send()
    .await
    .parse_or_panic::<WorkspacePB>()
}

pub async fn read_workspace(sdk: &EventIntegrationTest, workspace_id: String) -> WorkspacePB {
  let request = WorkspaceIdPB {
    value: workspace_id,
  };
  EventBuilder::new(sdk.clone())
    .event(ReadCurrentWorkspace)
    .payload(request.clone())
    .async_send()
    .await
    .parse_or_panic::<WorkspacePB>()
}

pub async fn create_view(
  sdk: &EventIntegrationTest,
  parent_view_id: &str,
  name: &str,
  _desc: &str,
  layout: ViewLayout,
) -> ViewPB {
  let request = CreateViewPayloadPB {
    parent_view_id: parent_view_id.to_string(),
    name: name.to_string(),
    thumbnail: None,
    layout: layout.into(),
    initial_data: vec![],
    meta: Default::default(),
    set_as_current: true,
    index: None,
    section: None,
    view_id: None,
    extra: None,
  };
  EventBuilder::new(sdk.clone())
    .event(CreateView)
    .payload(request)
    .async_send()
    .await
    .parse_or_panic::<ViewPB>()
}

pub async fn read_view(sdk: &EventIntegrationTest, view_id: &str) -> ViewPB {
  let view_id = ViewIdPB {
    value: view_id.to_string(),
  };
  EventBuilder::new(sdk.clone())
    .event(GetView)
    .payload(view_id)
    .async_send()
    .await
    .parse_or_panic::<ViewPB>()
}

pub async fn move_view(
  sdk: &EventIntegrationTest,
  view_id: String,
  parent_id: String,
  prev_view_id: Option<String>,
) {
  let payload = MoveNestedViewPayloadPB {
    view_id,
    new_parent_id: parent_id,
    prev_view_id,
    from_section: None,
    to_section: None,
  };
  let error = EventBuilder::new(sdk.clone())
    .event(MoveNestedView)
    .payload(payload)
    .async_send()
    .await
    .error();

  assert!(error.is_none());
}
pub async fn update_view(
  sdk: &EventIntegrationTest,
  view_id: &str,
  name: Option<String>,
  desc: Option<String>,
  is_favorite: Option<bool>,
) {
  println!("Toggling update view {:?}", is_favorite);
  let request = UpdateViewPayloadPB {
    view_id: view_id.to_string(),
    name,
    desc,
    is_favorite,
    ..Default::default()
  };
  EventBuilder::new(sdk.clone())
    .event(UpdateView)
    .payload(request)
    .async_send()
    .await;
}

pub async fn update_view_icon(sdk: &EventIntegrationTest, view_id: &str, icon: Option<ViewIconPB>) {
  let request = UpdateViewIconPayloadPB {
    view_id: view_id.to_string(),
    icon,
  };
  EventBuilder::new(sdk.clone())
    .event(UpdateViewIcon)
    .payload(request)
    .async_send()
    .await;
}

pub async fn delete_view(sdk: &EventIntegrationTest, view_ids: Vec<String>) {
  let request = RepeatedViewIdPB { items: view_ids };
  EventBuilder::new(sdk.clone())
    .event(DeleteView)
    .payload(request)
    .async_send()
    .await;
}

pub async fn read_trash(sdk: &EventIntegrationTest) -> RepeatedTrashPB {
  EventBuilder::new(sdk.clone())
    .event(ListTrashItems)
    .async_send()
    .await
    .parse_or_panic::<RepeatedTrashPB>()
}

pub async fn restore_app_from_trash(sdk: &EventIntegrationTest, app_id: &str) {
  let id = TrashIdPB {
    id: app_id.to_owned(),
  };
  EventBuilder::new(sdk.clone())
    .event(RestoreTrashItem)
    .payload(id)
    .async_send()
    .await;
}

pub async fn restore_view_from_trash(sdk: &EventIntegrationTest, view_id: &str) {
  let id = TrashIdPB {
    id: view_id.to_owned(),
  };
  EventBuilder::new(sdk.clone())
    .event(RestoreTrashItem)
    .payload(id)
    .async_send()
    .await;
}

pub async fn delete_all_trash(sdk: &EventIntegrationTest) {
  EventBuilder::new(sdk.clone())
    .event(PermanentlyDeleteAllTrashItem)
    .async_send()
    .await;
}

pub async fn toggle_favorites(sdk: &EventIntegrationTest, view_id: Vec<String>) {
  let request = RepeatedViewIdPB { items: view_id };
  EventBuilder::new(sdk.clone())
    .event(ToggleFavorite)
    .payload(request)
    .async_send()
    .await;
}

pub async fn read_favorites(sdk: &EventIntegrationTest) -> RepeatedFavoriteViewPB {
  EventBuilder::new(sdk.clone())
    .event(ReadFavorites)
    .async_send()
    .await
    .parse_or_panic::<RepeatedFavoriteViewPB>()
}