crates/assists/src/tests.rs

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