tests/integration_test.rs

   1 extern crate lemmy_server;
   2
   3 use activitystreams::{
   4   activity::{kind::CreateType, ActorAndObject},
   5   base::{BaseExt, ExtendsExt},
   6   object::{Note, ObjectExt},
   7 };
   8 use actix::prelude::*;
   9 use actix_web::{test::TestRequest, web};
  10 use chrono::Utc;
  11 use diesel::{
  12   r2d2::{ConnectionManager, Pool},
  13   PgConnection,
  14 };
  15 use http_signature_normalization_actix::PrepareVerifyError;
  16 use lemmy_db::{
  17   user::{User_, *},
  18   Crud,
  19   ListingType,
  20   SortType,
  21 };
  22 use lemmy_rate_limit::{rate_limiter::RateLimiter, RateLimit};
  23 use lemmy_server::{
  24   apub::{
  25     activity_queue::create_activity_queue,
  26     inbox::shared_inbox::{shared_inbox, ValidTypes},
  27   },
  28   websocket::chat_server::ChatServer,
  29   LemmyContext,
  30 };
  31 use lemmy_utils::{apub::generate_actor_keypair, settings::Settings};
  32 use reqwest::Client;
  33 use std::sync::Arc;
  34 use tokio::sync::Mutex;
  35 use url::Url;
  36
  37 fn create_context() -> LemmyContext {
  38   let settings = Settings::get();
  39   let db_url = settings.get_database_url();
  40   let manager = ConnectionManager::<PgConnection>::new(&db_url);
  41   let pool = Pool::builder()
  42     .max_size(settings.database.pool_size)
  43     .build(manager)
  44     .unwrap();
  45   let rate_limiter = RateLimit {
  46     rate_limiter: Arc::new(Mutex::new(RateLimiter::default())),
  47   };
  48   let activity_queue = create_activity_queue();
  49   let chat_server = ChatServer::startup(
  50     pool.clone(),
  51     rate_limiter.clone(),
  52     Client::default(),
  53     activity_queue.clone(),
  54   )
  55   .start();
  56   LemmyContext::new(
  57     pool,
  58     chat_server,
  59     Client::default(),
  60     create_activity_queue(),
  61   )
  62 }
  63
  64 fn create_user(conn: &PgConnection) -> User_ {
  65   let user_keypair = generate_actor_keypair().unwrap();
  66   let new_user = UserForm {
  67     name: "integration_user_1".into(),
  68     preferred_username: None,
  69     password_encrypted: "nope".into(),
  70     email: None,
  71     matrix_user_id: None,
  72     avatar: None,
  73     banner: None,
  74     admin: false,
  75     banned: false,
  76     updated: None,
  77     show_nsfw: false,
  78     theme: "darkly".into(),
  79     default_sort_type: SortType::Hot as i16,
  80     default_listing_type: ListingType::Subscribed as i16,
  81     lang: "browser".into(),
  82     show_avatars: true,
  83     send_notifications_to_email: false,
  84     actor_id: Some("http://localhost:8536/u/integration_user_1".to_string()),
  85     bio: None,
  86     local: true,
  87     private_key: Some(user_keypair.private_key),
  88     public_key: Some(user_keypair.public_key),
  89     last_refreshed_at: None,
  90   };
  91
  92   User_::create(&conn, &new_user).unwrap()
  93 }
  94
  95 fn create_activity(user_id: String) -> web::Json<ActorAndObject<ValidTypes>> {
  96   let mut activity =
  97     ActorAndObject::<CreateType>::new(user_id, Note::new().into_any_base().unwrap());
  98   activity
  99     .set_id(Url::parse("http://localhost:8536/create/1").unwrap())
 100     .set_many_ccs(vec![Url::parse("http://localhost:8536/c/main").unwrap()]);
 101   let activity = serde_json::to_value(&activity).unwrap();
 102   let activity: ActorAndObject<ValidTypes> = serde_json::from_value(activity).unwrap();
 103   web::Json(activity)
 104 }
 105
 106 #[actix_rt::test]
 107 async fn test_expired_signature() {
 108   let time1 = Utc::now().timestamp();
 109   let time2 = Utc::now().timestamp();
 110   let signature = format!(
 111     r#"keyId="my-key-id",algorithm="hs2019",created="{}",expires="{}",headers="(request-target) (created) (expires) date content-type",signature="blah blah blah""#,
 112     time1, time2
 113   );
 114   let request = TestRequest::post()
 115     .uri("http://localhost:8536/inbox")
 116     .header("Signature", signature)
 117     .to_http_request();
 118   let context = create_context();
 119   let user = create_user(&context.pool().get().unwrap());
 120   let activity = create_activity(user.actor_id);
 121   let response = shared_inbox(request, activity, web::Data::new(context)).await;
 122   assert_eq!(
 123     format!("{}", response.err().unwrap()),
 124     format!("{}", PrepareVerifyError::Expired)
 125   );
 126 }