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::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             let change = source_change.source_file_edits.pop().unwrap();
 102
 103             let mut actual = db.file_text(change.file_id).as_ref().to_owned();
 104             change.edit.apply(&mut actual);
 105             assert_eq_text!(after, &actual);
 106         }
 107         (Some(assist), ExpectedResult::Target(target)) => {
 108             let range = assist.assist.target;
 109             assert_eq_text!(&text_without_caret[range], target);
 110         }
 111         (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
 112         (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
 113             panic!("code action is not applicable")
 114         }
 115         (None, ExpectedResult::NotApplicable) => (),
 116     };
 117 }
 118
 119 #[test]
 120 fn assist_order_field_struct() {
 121     let before = "struct Foo { <|>bar: u32 }";
 122     let (before_cursor_pos, before) = extract_offset(before);
 123     let (db, file_id) = with_single_file(&before);
 124     let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
 125     let assists = Assist::resolved(&db, &AssistConfig::default(), frange);
 126     let mut assists = assists.iter();
 127
 128     assert_eq!(
 129         assists.next().expect("expected assist").assist.label,
 130         "Change visibility to pub(crate)"
 131     );
 132     assert_eq!(assists.next().expect("expected assist").assist.label, "Add `#[derive]`");
 133 }
 134
 135 #[test]
 136 fn assist_order_if_expr() {
 137     let before = "
 138     pub fn test_some_range(a: int) -> bool {
 139         if let 2..6 = <|>5<|> {
 140             true
 141         } else {
 142             false
 143         }
 144     }";
 145     let (range, before) = extract_range(before);
 146     let (db, file_id) = with_single_file(&before);
 147     let frange = FileRange { file_id, range };
 148     let assists = Assist::resolved(&db, &AssistConfig::default(), frange);
 149     let mut assists = assists.iter();
 150
 151     assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
 152     assert_eq!(assists.next().expect("expected assist").assist.label, "Replace with match");
 153 }
 154
 155 #[test]
 156 fn assist_filter_works() {
 157     let before = "
 158     pub fn test_some_range(a: int) -> bool {
 159         if let 2..6 = <|>5<|> {
 160             true
 161         } else {
 162             false
 163         }
 164     }";
 165     let (range, before) = extract_range(before);
 166     let (db, file_id) = with_single_file(&before);
 167     let frange = FileRange { file_id, range };
 168
 169     {
 170         let mut cfg = AssistConfig::default();
 171         cfg.allowed = Some(vec![AssistKind::Refactor]);
 172
 173         let assists = Assist::resolved(&db, &cfg, frange);
 174         let mut assists = assists.iter();
 175
 176         assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
 177         assert_eq!(assists.next().expect("expected assist").assist.label, "Replace with match");
 178     }
 179
 180     {
 181         let mut cfg = AssistConfig::default();
 182         cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
 183         let assists = Assist::resolved(&db, &cfg, frange);
 184         assert_eq!(assists.len(), 1);
 185
 186         let mut assists = assists.iter();
 187         assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
 188     }
 189
 190     {
 191         let mut cfg = AssistConfig::default();
 192         cfg.allowed = Some(vec![AssistKind::QuickFix]);
 193         let assists = Assist::resolved(&db, &cfg, frange);
 194         assert!(assists.is_empty(), "All asserts but quickfixes should be filtered out");
 195     }
 196 }