crates/assists/src/tests.rs

   1 mod generated;
   2
   3 use hir::Semantics;
   4 use ide_db::{
   5     base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt},
   6     helpers::{insert_use::MergeBehavior, SnippetCap},
   7     source_change::FileSystemEdit,
   8     RootDatabase,
   9 };
  10 use syntax::TextRange;
  11 use test_utils::{assert_eq_text, extract_offset, extract_range};
  12
  13 use crate::{
  14     handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind, Assists, InsertUseConfig,
  15 };
  16 use stdx::{format_to, trim_indent};
  17
  18 pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
  19     snippet_cap: SnippetCap::new(true),
  20     allowed: None,
  21     insert_use: InsertUseConfig {
  22         merge: Some(MergeBehavior::Full),
  23         prefix_kind: hir::PrefixKind::Plain,
  24     },
  25 };
  26
  27 pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
  28     RootDatabase::with_single_file(text)
  29 }
  30
  31 pub(crate) fn check_assist(assist: Handler, ra_fixture_before: &str, ra_fixture_after: &str) {
  32     let ra_fixture_after = trim_indent(ra_fixture_after);
  33     check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after), None);
  34 }
  35
  36 // There is no way to choose what assist within a group you want to test against,
  37 // so this is here to allow you choose.
  38 pub(crate) fn check_assist_by_label(
  39     assist: Handler,
  40     ra_fixture_before: &str,
  41     ra_fixture_after: &str,
  42     label: &str,
  43 ) {
  44     let ra_fixture_after = trim_indent(ra_fixture_after);
  45     check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after), Some(label));
  46 }
  47
  48 // FIXME: instead of having a separate function here, maybe use
  49 // `extract_ranges` and mark the target as `<target> </target>` in the
  50 // fixture?
  51 pub(crate) fn check_assist_target(assist: Handler, ra_fixture: &str, target: &str) {
  52     check(assist, ra_fixture, ExpectedResult::Target(target), None);
  53 }
  54
  55 pub(crate) fn check_assist_not_applicable(assist: Handler, ra_fixture: &str) {
  56     check(assist, ra_fixture, ExpectedResult::NotApplicable, None);
  57 }
  58
  59 fn check_doc_test(assist_id: &str, before: &str, after: &str) {
  60     let after = trim_indent(after);
  61     let (db, file_id, selection) = RootDatabase::with_range_or_offset(&before);
  62     let before = db.file_text(file_id).to_string();
  63     let frange = FileRange { file_id, range: selection.into() };
  64
  65     let assist = Assist::get(&db, &TEST_CONFIG, true, frange)
  66         .into_iter()
  67         .find(|assist| assist.id.0 == assist_id)
  68         .unwrap_or_else(|| {
  69             panic!(
  70                 "\n\nAssist is not applicable: {}\nAvailable assists: {}",
  71                 assist_id,
  72                 Assist::get(&db, &TEST_CONFIG, false, frange)
  73                     .into_iter()
  74                     .map(|assist| assist.id.0)
  75                     .collect::<Vec<_>>()
  76                     .join(", ")
  77             )
  78         });
  79
  80     let actual = {
  81         let source_change = assist.source_change.unwrap();
  82         let mut actual = before;
  83         for source_file_edit in source_change.source_file_edits {
  84             if source_file_edit.file_id == file_id {
  85                 source_file_edit.edit.apply(&mut actual)
  86             }
  87         }
  88         actual
  89     };
  90     assert_eq_text!(&after, &actual);
  91 }
  92
  93 enum ExpectedResult<'a> {
  94     NotApplicable,
  95     After(&'a str),
  96     Target(&'a str),
  97 }
  98
  99 fn check(handler: Handler, before: &str, expected: ExpectedResult, assist_label: Option<&str>) {
 100     let (db, file_with_caret_id, range_or_offset) = RootDatabase::with_range_or_offset(before);
 101     let text_without_caret = db.file_text(file_with_caret_id).to_string();
 102
 103     let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
 104
 105     let sema = Semantics::new(&db);
 106     let config = TEST_CONFIG;
 107     let ctx = AssistContext::new(sema, &config, frange);
 108     let mut acc = Assists::new(&ctx, true);
 109     handler(&mut acc, &ctx);
 110     let mut res = acc.finish();
 111
 112     let assist = match assist_label {
 113         Some(label) => res.into_iter().find(|resolved| resolved.label == label),
 114         None => res.pop(),
 115     };
 116
 117     match (assist, expected) {
 118         (Some(assist), ExpectedResult::After(after)) => {
 119             let mut source_change = assist.source_change.unwrap();
 120             assert!(!source_change.source_file_edits.is_empty());
 121             let skip_header = source_change.source_file_edits.len() == 1
 122                 && source_change.file_system_edits.len() == 0;
 123             source_change.source_file_edits.sort_by_key(|it| it.file_id);
 124
 125             let mut buf = String::new();
 126             for source_file_edit in source_change.source_file_edits {
 127                 let mut text = db.file_text(source_file_edit.file_id).as_ref().to_owned();
 128                 source_file_edit.edit.apply(&mut text);
 129                 if !skip_header {
 130                     let sr = db.file_source_root(source_file_edit.file_id);
 131                     let sr = db.source_root(sr);
 132                     let path = sr.path_for_file(&source_file_edit.file_id).unwrap();
 133                     format_to!(buf, "//- {}\n", path)
 134                 }
 135                 buf.push_str(&text);
 136             }
 137
 138             for file_system_edit in source_change.file_system_edits.clone() {
 139                 match file_system_edit {
 140                     FileSystemEdit::CreateFile { dst, initial_contents } => {
 141                         let sr = db.file_source_root(dst.anchor);
 142                         let sr = db.source_root(sr);
 143                         let mut base = sr.path_for_file(&dst.anchor).unwrap().clone();
 144                         base.pop();
 145                         let created_file_path = format!("{}{}", base.to_string(), &dst.path[1..]);
 146                         format_to!(buf, "//- {}\n", created_file_path);
 147                         buf.push_str(&initial_contents);
 148                     }
 149                     _ => (),
 150                 }
 151             }
 152
 153             assert_eq_text!(after, &buf);
 154         }
 155         (Some(assist), ExpectedResult::Target(target)) => {
 156             let range = assist.target;
 157             assert_eq_text!(&text_without_caret[range], target);
 158         }
 159         (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
 160         (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
 161             panic!("code action is not applicable")
 162         }
 163         (None, ExpectedResult::NotApplicable) => (),
 164     };
 165 }
 166
 167 #[test]
 168 fn assist_order_field_struct() {
 169     let before = "struct Foo { $0bar: u32 }";
 170     let (before_cursor_pos, before) = extract_offset(before);
 171     let (db, file_id) = with_single_file(&before);
 172     let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
 173     let assists = Assist::get(&db, &TEST_CONFIG, false, frange);
 174     let mut assists = assists.iter();
 175
 176     assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
 177     assert_eq!(assists.next().expect("expected assist").label, "Add `#[derive]`");
 178 }
 179
 180 #[test]
 181 fn assist_order_if_expr() {
 182     let before = "
 183     pub fn test_some_range(a: int) -> bool {
 184         if let 2..6 = $05$0 {
 185             true
 186         } else {
 187             false
 188         }
 189     }";
 190     let (range, before) = extract_range(before);
 191     let (db, file_id) = with_single_file(&before);
 192     let frange = FileRange { file_id, range };
 193     let assists = Assist::get(&db, &TEST_CONFIG, false, frange);
 194     let mut assists = assists.iter();
 195
 196     assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
 197     assert_eq!(assists.next().expect("expected assist").label, "Replace with match");
 198 }
 199
 200 #[test]
 201 fn assist_filter_works() {
 202     let before = "
 203     pub fn test_some_range(a: int) -> bool {
 204         if let 2..6 = $05$0 {
 205             true
 206         } else {
 207             false
 208         }
 209     }";
 210     let (range, before) = extract_range(before);
 211     let (db, file_id) = with_single_file(&before);
 212     let frange = FileRange { file_id, range };
 213
 214     {
 215         let mut cfg = TEST_CONFIG;
 216         cfg.allowed = Some(vec![AssistKind::Refactor]);
 217
 218         let assists = Assist::get(&db, &cfg, false, frange);
 219         let mut assists = assists.iter();
 220
 221         assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
 222         assert_eq!(assists.next().expect("expected assist").label, "Replace with match");
 223     }
 224
 225     {
 226         let mut cfg = TEST_CONFIG;
 227         cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
 228         let assists = Assist::get(&db, &cfg, false, frange);
 229         assert_eq!(assists.len(), 1);
 230
 231         let mut assists = assists.iter();
 232         assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
 233     }
 234
 235     {
 236         let mut cfg = TEST_CONFIG;
 237         cfg.allowed = Some(vec![AssistKind::QuickFix]);
 238         let assists = Assist::get(&db, &cfg, false, frange);
 239         assert!(assists.is_empty(), "All asserts but quickfixes should be filtered out");
 240     }
 241 }