5 base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt},
6 helpers::{insert_use::MergeBehavior, SnippetCap},
7 source_change::FileSystemEdit,
10 use syntax::TextRange;
11 use test_utils::{assert_eq_text, extract_offset, extract_range};
14 handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind, Assists, InsertUseConfig,
16 use stdx::{format_to, trim_indent};
18 pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
19 snippet_cap: SnippetCap::new(true),
21 insert_use: InsertUseConfig {
22 merge: Some(MergeBehavior::Full),
23 prefix_kind: hir::PrefixKind::Plain,
27 pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
28 RootDatabase::with_single_file(text)
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);
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(
40 ra_fixture_before: &str,
41 ra_fixture_after: &str,
44 let ra_fixture_after = trim_indent(ra_fixture_after);
45 check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after), Some(label));
48 // FIXME: instead of having a separate function here, maybe use
49 // `extract_ranges` and mark the target as `<target> </target>` in the
51 pub(crate) fn check_assist_target(assist: Handler, ra_fixture: &str, target: &str) {
52 check(assist, ra_fixture, ExpectedResult::Target(target), None);
55 pub(crate) fn check_assist_not_applicable(assist: Handler, ra_fixture: &str) {
56 check(assist, ra_fixture, ExpectedResult::NotApplicable, None);
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() };
65 let assist = Assist::get(&db, &TEST_CONFIG, true, frange)
67 .find(|assist| assist.id.0 == assist_id)
70 "\n\nAssist is not applicable: {}\nAvailable assists: {}",
72 Assist::get(&db, &TEST_CONFIG, false, frange)
74 .map(|assist| assist.id.0)
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)
90 assert_eq_text!(&after, &actual);
93 enum ExpectedResult<'a> {
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();
103 let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
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();
112 let assist = match assist_label {
113 Some(label) => res.into_iter().find(|resolved| resolved.label == label),
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);
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);
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)
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();
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);
153 assert_eq_text!(after, &buf);
155 (Some(assist), ExpectedResult::Target(target)) => {
156 let range = assist.target;
157 assert_eq_text!(&text_without_caret[range], target);
159 (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
160 (None, ExpectedResult::After(_)) | (None, ExpectedResult::Target(_)) => {
161 panic!("code action is not applicable")
163 (None, ExpectedResult::NotApplicable) => (),
168 fn assist_order_field_struct() {
169 let before = "struct Foo { <|>bar: 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();
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]`");
181 fn assist_order_if_expr() {
183 pub fn test_some_range(a: int) -> bool {
184 if let 2..6 = <|>5<|> {
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();
196 assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
197 assert_eq!(assists.next().expect("expected assist").label, "Replace with match");
201 fn assist_filter_works() {
203 pub fn test_some_range(a: int) -> bool {
204 if let 2..6 = <|>5<|> {
210 let (range, before) = extract_range(before);
211 let (db, file_id) = with_single_file(&before);
212 let frange = FileRange { file_id, range };
215 let mut cfg = TEST_CONFIG;
216 cfg.allowed = Some(vec![AssistKind::Refactor]);
218 let assists = Assist::get(&db, &cfg, false, frange);
219 let mut assists = assists.iter();
221 assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
222 assert_eq!(assists.next().expect("expected assist").label, "Replace with match");
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);
231 let mut assists = assists.iter();
232 assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
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");