Remove taskchampion-sync-server (#3380)
This crate has been moved to https://github.com/GothenburgBitFactory/taskchampion-sync-server. The integration-tests repo used the sync server to test integration between taskchampion and the sync-server. We should do that again, but after taskchampion moves to its own repo (#3209). In the interim, the cross-sync integration test can simply test syncing between local servers, but the snapshot test is no longer useful as the local server does not support snapshots.
This commit is contained in:
Dustin J. Mitchell
committed by
GitHub
GitHub
parent
304b84e4da
commit
f054a4061e
@@ -1,97 +1,66 @@
|
||||
use actix_web::{App, HttpServer};
|
||||
use pretty_assertions::assert_eq;
|
||||
use taskchampion::{Replica, ServerConfig, Status, StorageConfig, Uuid};
|
||||
use taskchampion_sync_server::{storage::InMemoryStorage, Server};
|
||||
use taskchampion::{Replica, ServerConfig, Status, StorageConfig};
|
||||
use tempfile::TempDir;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn cross_sync() -> anyhow::Result<()> {
|
||||
async fn server() -> anyhow::Result<u16> {
|
||||
let _ = env_logger::builder()
|
||||
.is_test(true)
|
||||
.filter_level(log::LevelFilter::Trace)
|
||||
.try_init();
|
||||
#[test]
|
||||
fn cross_sync() -> anyhow::Result<()> {
|
||||
// set up two replicas, and demonstrate replication between them
|
||||
let mut rep1 = Replica::new(StorageConfig::InMemory.into_storage()?);
|
||||
let mut rep2 = Replica::new(StorageConfig::InMemory.into_storage()?);
|
||||
|
||||
let server = Server::new(Default::default(), Box::new(InMemoryStorage::new()));
|
||||
let httpserver = HttpServer::new(move || App::new().configure(|sc| server.config(sc)))
|
||||
.bind("0.0.0.0:0")?;
|
||||
let tmp_dir = TempDir::new().expect("TempDir failed");
|
||||
let server_config = ServerConfig::Local {
|
||||
server_dir: tmp_dir.path().to_path_buf(),
|
||||
};
|
||||
let mut server = server_config.into_server()?;
|
||||
|
||||
// bind was to :0, so the kernel will have selected an unused port
|
||||
let port = httpserver.addrs()[0].port();
|
||||
actix_rt::spawn(httpserver.run());
|
||||
Ok(port)
|
||||
}
|
||||
// add some tasks on rep1
|
||||
let t1 = rep1.new_task(Status::Pending, "test 1".into())?;
|
||||
let t2 = rep1.new_task(Status::Pending, "test 2".into())?;
|
||||
|
||||
fn client(port: u16) -> anyhow::Result<()> {
|
||||
// set up two replicas, and demonstrate replication between them
|
||||
let mut rep1 = Replica::new(StorageConfig::InMemory.into_storage()?);
|
||||
let mut rep2 = Replica::new(StorageConfig::InMemory.into_storage()?);
|
||||
// modify t1
|
||||
let mut t1 = t1.into_mut(&mut rep1);
|
||||
t1.start()?;
|
||||
let t1 = t1.into_immut();
|
||||
|
||||
let client_id = Uuid::new_v4();
|
||||
let encryption_secret = b"abc123".to_vec();
|
||||
let make_server = || {
|
||||
ServerConfig::Remote {
|
||||
origin: format!("http://127.0.0.1:{}", port),
|
||||
client_id,
|
||||
encryption_secret: encryption_secret.clone(),
|
||||
}
|
||||
.into_server()
|
||||
};
|
||||
rep1.sync(&mut server, false)?;
|
||||
rep2.sync(&mut server, false)?;
|
||||
|
||||
let mut serv1 = make_server()?;
|
||||
let mut serv2 = make_server()?;
|
||||
// those tasks should exist on rep2 now
|
||||
let t12 = rep2
|
||||
.get_task(t1.get_uuid())?
|
||||
.expect("expected task 1 on rep2");
|
||||
let t22 = rep2
|
||||
.get_task(t2.get_uuid())?
|
||||
.expect("expected task 2 on rep2");
|
||||
|
||||
// add some tasks on rep1
|
||||
let t1 = rep1.new_task(Status::Pending, "test 1".into())?;
|
||||
let t2 = rep1.new_task(Status::Pending, "test 2".into())?;
|
||||
assert_eq!(t12.get_description(), "test 1");
|
||||
assert_eq!(t12.is_active(), true);
|
||||
assert_eq!(t22.get_description(), "test 2");
|
||||
assert_eq!(t22.is_active(), false);
|
||||
|
||||
// modify t1
|
||||
let mut t1 = t1.into_mut(&mut rep1);
|
||||
t1.start()?;
|
||||
let t1 = t1.into_immut();
|
||||
// make non-conflicting changes on the two replicas
|
||||
let mut t2 = t2.into_mut(&mut rep1);
|
||||
t2.set_status(Status::Completed)?;
|
||||
let t2 = t2.into_immut();
|
||||
|
||||
rep1.sync(&mut serv1, false)?;
|
||||
rep2.sync(&mut serv2, false)?;
|
||||
let mut t12 = t12.into_mut(&mut rep2);
|
||||
t12.set_status(Status::Completed)?;
|
||||
|
||||
// those tasks should exist on rep2 now
|
||||
let t12 = rep2
|
||||
.get_task(t1.get_uuid())?
|
||||
.expect("expected task 1 on rep2");
|
||||
let t22 = rep2
|
||||
.get_task(t2.get_uuid())?
|
||||
.expect("expected task 2 on rep2");
|
||||
// sync those changes back and forth
|
||||
rep1.sync(&mut server, false)?; // rep1 -> server
|
||||
rep2.sync(&mut server, false)?; // server -> rep2, rep2 -> server
|
||||
rep1.sync(&mut server, false)?; // server -> rep1
|
||||
|
||||
assert_eq!(t12.get_description(), "test 1");
|
||||
assert_eq!(t12.is_active(), true);
|
||||
assert_eq!(t22.get_description(), "test 2");
|
||||
assert_eq!(t22.is_active(), false);
|
||||
let t1 = rep1
|
||||
.get_task(t1.get_uuid())?
|
||||
.expect("expected task 1 on rep1");
|
||||
assert_eq!(t1.get_status(), Status::Completed);
|
||||
|
||||
// make non-conflicting changes on the two replicas
|
||||
let mut t2 = t2.into_mut(&mut rep1);
|
||||
t2.set_status(Status::Completed)?;
|
||||
let t2 = t2.into_immut();
|
||||
let t22 = rep2
|
||||
.get_task(t2.get_uuid())?
|
||||
.expect("expected task 2 on rep2");
|
||||
assert_eq!(t22.get_status(), Status::Completed);
|
||||
|
||||
let mut t12 = t12.into_mut(&mut rep2);
|
||||
t12.set_status(Status::Completed)?;
|
||||
|
||||
// sync those changes back and forth
|
||||
rep1.sync(&mut serv1, false)?; // rep1 -> server
|
||||
rep2.sync(&mut serv2, false)?; // server -> rep2, rep2 -> server
|
||||
rep1.sync(&mut serv1, false)?; // server -> rep1
|
||||
|
||||
let t1 = rep1
|
||||
.get_task(t1.get_uuid())?
|
||||
.expect("expected task 1 on rep1");
|
||||
assert_eq!(t1.get_status(), Status::Completed);
|
||||
|
||||
let t22 = rep2
|
||||
.get_task(t2.get_uuid())?
|
||||
.expect("expected task 2 on rep2");
|
||||
assert_eq!(t22.get_status(), Status::Completed);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
let port = server().await?;
|
||||
actix_rt::task::spawn_blocking(move || client(port)).await??;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1,98 +0,0 @@
|
||||
use actix_web::{App, HttpServer};
|
||||
use pretty_assertions::assert_eq;
|
||||
use taskchampion::{Replica, ServerConfig, Status, StorageConfig, Uuid};
|
||||
use taskchampion_sync_server::{
|
||||
storage::InMemoryStorage, Server, ServerConfig as SyncServerConfig,
|
||||
};
|
||||
|
||||
const NUM_VERSIONS: u32 = 50;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn sync_with_snapshots() -> anyhow::Result<()> {
|
||||
let _ = env_logger::builder()
|
||||
.is_test(true)
|
||||
.filter_level(log::LevelFilter::Trace)
|
||||
.try_init();
|
||||
|
||||
async fn server() -> anyhow::Result<u16> {
|
||||
let sync_server_config = SyncServerConfig {
|
||||
snapshot_days: 100,
|
||||
snapshot_versions: 3,
|
||||
};
|
||||
let server = Server::new(sync_server_config, Box::new(InMemoryStorage::new()));
|
||||
let httpserver = HttpServer::new(move || App::new().configure(|sc| server.config(sc)))
|
||||
.bind("0.0.0.0:0")?;
|
||||
|
||||
// bind was to :0, so the kernel will have selected an unused port
|
||||
let port = httpserver.addrs()[0].port();
|
||||
actix_rt::spawn(httpserver.run());
|
||||
Ok(port)
|
||||
}
|
||||
|
||||
fn client(port: u16) -> anyhow::Result<()> {
|
||||
let client_id = Uuid::new_v4();
|
||||
let encryption_secret = b"abc123".to_vec();
|
||||
let make_server = || {
|
||||
ServerConfig::Remote {
|
||||
origin: format!("http://127.0.0.1:{}", port),
|
||||
client_id,
|
||||
encryption_secret: encryption_secret.clone(),
|
||||
}
|
||||
.into_server()
|
||||
};
|
||||
|
||||
// first we set up a single replica and sync it a lot of times, to establish a sync history.
|
||||
let mut rep1 = Replica::new(StorageConfig::InMemory.into_storage()?);
|
||||
let mut serv1 = make_server()?;
|
||||
|
||||
let mut t1 = rep1.new_task(Status::Pending, "test 1".into())?;
|
||||
log::info!("Applying modifications on replica 1");
|
||||
for i in 0..=NUM_VERSIONS {
|
||||
let mut t1m = t1.into_mut(&mut rep1);
|
||||
t1m.start()?;
|
||||
t1m.stop()?;
|
||||
t1m.set_description(format!("revision {}", i))?;
|
||||
t1 = t1m.into_immut();
|
||||
|
||||
rep1.sync(&mut serv1, false)?;
|
||||
}
|
||||
|
||||
// now set up a second replica and sync it; it should catch up on that history, using a
|
||||
// snapshot. Note that we can't verify that it used a snapshot, because the server
|
||||
// currently keeps all versions (so rep2 could sync from the beginning of the version
|
||||
// history). You can manually verify that it is applying a snapshot by adding
|
||||
// `assert!(false)` below and skimming the logs.
|
||||
|
||||
let mut rep2 = Replica::new(StorageConfig::InMemory.into_storage()?);
|
||||
let mut serv2 = make_server()?;
|
||||
|
||||
log::info!("Syncing replica 2");
|
||||
rep2.sync(&mut serv2, false)?;
|
||||
|
||||
// those tasks should exist on rep2 now
|
||||
let t12 = rep2
|
||||
.get_task(t1.get_uuid())?
|
||||
.expect("expected task 1 on rep2");
|
||||
|
||||
assert_eq!(t12.get_description(), format!("revision {}", NUM_VERSIONS));
|
||||
assert_eq!(t12.is_active(), false);
|
||||
|
||||
// sync that back to replica 1
|
||||
t12.into_mut(&mut rep2)
|
||||
.set_description("sync-back".to_owned())?;
|
||||
rep2.sync(&mut serv2, false)?;
|
||||
rep1.sync(&mut serv1, false)?;
|
||||
|
||||
let t11 = rep1
|
||||
.get_task(t1.get_uuid())?
|
||||
.expect("expected task 1 on rep1");
|
||||
|
||||
assert_eq!(t11.get_description(), "sync-back");
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
let port = server().await?;
|
||||
actix_rt::task::spawn_blocking(move || client(port)).await??;
|
||||
Ok(())
|
||||
}
|
||||
Reference in New Issue
Block a user