3 use base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
5 use ide_db::RootDatabase;
7 use test_utils::{assert_eq_text, extract_offset, extract_range};
9 use crate::{handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind, Assists};
10 use stdx::trim_indent;
12 pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
13 RootDatabase::with_single_file(text)
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);
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(
25 ra_fixture_before: &str,
26 ra_fixture_after: &str,
29 let ra_fixture_after = trim_indent(ra_fixture_after);
30 check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after), Some(label));
33 // FIXME: instead of having a separate function here, maybe use
34 // `extract_ranges` and mark the target as `<target> </target>` in the
36 pub(crate) fn check_assist_target(assist: Handler, ra_fixture: &str, target: &str) {
37 check(assist, ra_fixture, ExpectedResult::Target(target), None);
40 pub(crate) fn check_assist_not_applicable(assist: Handler, ra_fixture: &str) {
41 check(assist, ra_fixture, ExpectedResult::NotApplicable, None);
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() };
50 let mut assist = Assist::resolved(&db, &AssistConfig::default(), frange)
52 .find(|assist| assist.assist.id.0 == assist_id)
55 "\n\nAssist is not applicable: {}\nAvailable assists: {}",
57 Assist::resolved(&db, &AssistConfig::default(), frange)
59 .map(|assist| assist.assist.id.0)
66 let change = assist.source_change.source_file_edits.pop().unwrap();
67 let mut actual = before;
68 change.edit.apply(&mut actual);
71 assert_eq_text!(&after, &actual);
74 enum ExpectedResult<'a> {
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();
84 let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
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();
93 let assist = match assist_label {
94 Some(label) => res.into_iter().find(|resolved| resolved.assist.label == label),
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();
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);
107 (Some(assist), ExpectedResult::Target(target)) => {
108 let range = assist.assist.target;
109 assert_eq_text!(&text_without_caret[range], target);
111 (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
112 (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
113 panic!("code action is not applicable")
115 (None, ExpectedResult::NotApplicable) => (),
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();
129 assists.next().expect("expected assist").assist.label,
130 "Change visibility to pub(crate)"
132 assert_eq!(assists.next().expect("expected assist").assist.label, "Add `#[derive]`");
136 fn assist_order_if_expr() {
138 pub fn test_some_range(a: int) -> bool {
139 if let 2..6 = <|>5<|> {
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();
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");
156 fn assist_filter_works() {
158 pub fn test_some_range(a: int) -> bool {
159 if let 2..6 = <|>5<|> {
165 let (range, before) = extract_range(before);
166 let (db, file_id) = with_single_file(&before);
167 let frange = FileRange { file_id, range };
170 let mut cfg = AssistConfig::default();
171 cfg.allowed = Some(vec![AssistKind::Refactor]);
173 let assists = Assist::resolved(&db, &cfg, frange);
174 let mut assists = assists.iter();
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");
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);
186 let mut assists = assists.iter();
187 assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
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");