Skip to content

Commit d5e593f

Browse files
jvaticjvatic
committed
chore: normalize test cases
1 parent d783ebd commit d5e593f

File tree

1 file changed

+130
-119
lines changed

1 file changed

+130
-119
lines changed

‎src/lib.rs

+130-119
Original file line numberDiff line numberDiff line change
@@ -114,142 +114,169 @@ impl fmt::Display for SyntaxTree {
114114
mod tests {
115115
use super::*;
116116

117-
#[test]
118-
fn diff_create_table() {
119-
let sql_a = "CREATE TABLE foo(\
120-
id int PRIMARY KEY
121-
)";
122-
let sql_b = "CREATE TABLE foo(\
123-
id int PRIMARY KEY
124-
);\
125-
\
126-
CREATE TABLE bar (id INT PRIMARY KEY);";
127-
let sql_diff = "CREATE TABLE bar (id INT PRIMARY KEY);";
117+
#[derive(Debug)]
118+
struct TestCase {
119+
dialect: Dialect,
120+
sql_a: &'static str,
121+
sql_b: &'static str,
122+
expect: &'static str,
123+
}
128124

129-
let ast_a = SyntaxTree::builder().sql(sql_a).build().unwrap();
130-
let ast_b = SyntaxTree::builder().sql(sql_b).build().unwrap();
131-
let ast_diff = ast_a.diff(&ast_b);
125+
fn run_test_case<F>(tc: &TestCase, testfn: F)
126+
where
127+
F: Fn(SyntaxTree, SyntaxTree) -> SyntaxTree,
128+
{
129+
let ast_a = SyntaxTree::builder()
130+
.dialect(tc.dialect.clone())
131+
.sql(tc.sql_a)
132+
.build()
133+
.unwrap();
134+
let ast_b = SyntaxTree::builder()
135+
.dialect(tc.dialect.clone())
136+
.sql(tc.sql_b)
137+
.build()
138+
.unwrap();
139+
let actual = testfn(ast_a, ast_b);
140+
assert_eq!(actual.to_string(), tc.expect, "{tc:?}");
141+
}
132142

133-
assert_eq!(ast_diff.unwrap().to_string(), sql_diff);
143+
fn run_test_cases<F>(test_cases: Vec<TestCase>, testfn: F)
144+
where
145+
F: Fn(SyntaxTree, SyntaxTree) -> SyntaxTree,
146+
{
147+
test_cases
148+
.into_iter()
149+
.for_each(|tc| run_test_case(&tc, |ast_a, ast_b| testfn(ast_a, ast_b)));
134150
}
135151

136152
#[test]
137-
fn diff_drop_table() {
138-
let sql_a = "CREATE TABLE foo(\
139-
id int PRIMARY KEY
140-
);\
141-
\
142-
CREATE TABLE bar (id INT PRIMARY KEY);";
143-
let sql_b = "CREATE TABLE foo(\
144-
id int PRIMARY KEY
145-
)";
146-
let sql_diff = "DROP TABLE bar;";
147-
148-
let ast_a = SyntaxTree::builder().sql(sql_a).build().unwrap();
149-
let ast_b = SyntaxTree::builder().sql(sql_b).build().unwrap();
150-
let ast_diff = ast_a.diff(&ast_b);
153+
fn diff_create_table() {
154+
run_test_cases(
155+
vec![TestCase {
156+
dialect: Dialect::Generic,
157+
sql_a: "CREATE TABLE foo(\
158+
id int PRIMARY KEY
159+
)",
160+
sql_b: "CREATE TABLE foo(\
161+
id int PRIMARY KEY
162+
);\
163+
CREATE TABLE bar (id INT PRIMARY KEY);",
164+
expect: "CREATE TABLE bar (id INT PRIMARY KEY);",
165+
}],
166+
|ast_a, ast_b| ast_a.diff(&ast_b).unwrap(),
167+
);
168+
}
151169

152-
assert_eq!(ast_diff.unwrap().to_string(), sql_diff);
170+
#[test]
171+
fn diff_drop_table() {
172+
run_test_cases(
173+
vec![TestCase {
174+
dialect: Dialect::Generic,
175+
sql_a: "CREATE TABLE foo(\
176+
id int PRIMARY KEY
177+
);\
178+
CREATE TABLE bar (id INT PRIMARY KEY);",
179+
sql_b: "CREATE TABLE foo(\
180+
id int PRIMARY KEY
181+
)",
182+
expect: "DROP TABLE bar;",
183+
}],
184+
|ast_a, ast_b| ast_a.diff(&ast_b).unwrap(),
185+
);
153186
}
154187

155188
#[test]
156189
fn diff_add_column() {
157-
let sql_a = "CREATE TABLE foo(\
158-
id int PRIMARY KEY
159-
)";
160-
let sql_b = "CREATE TABLE foo(\
161-
id int PRIMARY KEY,
162-
bar text
163-
)";
164-
let sql_diff = "ALTER TABLE\n foo\nADD\n COLUMN bar TEXT;";
165-
166-
let ast_a = SyntaxTree::builder().sql(sql_a).build().unwrap();
167-
let ast_b = SyntaxTree::builder().sql(sql_b).build().unwrap();
168-
let ast_diff = ast_a.diff(&ast_b);
169-
170-
assert_eq!(ast_diff.unwrap().to_string(), sql_diff);
190+
run_test_cases(
191+
vec![TestCase {
192+
dialect: Dialect::Generic,
193+
sql_a: "CREATE TABLE foo(\
194+
id int PRIMARY KEY
195+
)",
196+
sql_b: "CREATE TABLE foo(\
197+
id int PRIMARY KEY,
198+
bar text
199+
)",
200+
expect: "ALTER TABLE\n foo\nADD\n COLUMN bar TEXT;",
201+
}],
202+
|ast_a, ast_b| ast_a.diff(&ast_b).unwrap(),
203+
);
171204
}
172205

173206
#[test]
174207
fn diff_drop_column() {
175-
let sql_a = "CREATE TABLE foo(\
176-
id int PRIMARY KEY,
177-
bar text
178-
)";
179-
let sql_b = "CREATE TABLE foo(\
180-
id int PRIMARY KEY
181-
)";
182-
let sql_diff = "ALTER TABLE\n foo DROP COLUMN bar;";
183-
184-
let ast_a = SyntaxTree::builder().sql(sql_a).build().unwrap();
185-
let ast_b = SyntaxTree::builder().sql(sql_b).build().unwrap();
186-
let ast_diff = ast_a.diff(&ast_b);
187-
188-
assert_eq!(ast_diff.unwrap().to_string(), sql_diff);
208+
run_test_cases(
209+
vec![TestCase {
210+
dialect: Dialect::Generic,
211+
sql_a: "CREATE TABLE foo(\
212+
id int PRIMARY KEY,
213+
bar text
214+
)",
215+
sql_b: "CREATE TABLE foo(\
216+
id int PRIMARY KEY
217+
)",
218+
expect: "ALTER TABLE\n foo DROP COLUMN bar;",
219+
}],
220+
|ast_a, ast_b| ast_a.diff(&ast_b).unwrap(),
221+
);
189222
}
190223

191224
#[test]
192225
fn apply_create_table() {
193-
let sql_a = "CREATE TABLE bar (id INT PRIMARY KEY);";
194-
let sql_b = "CREATE TABLE foo (id INT PRIMARY KEY);";
195-
let sql_res = sql_a.to_owned() + "\n\n" + sql_b;
196-
197-
let ast_a = SyntaxTree::builder().sql(sql_a).build().unwrap();
198-
let ast_b = SyntaxTree::builder().sql(sql_b).build().unwrap();
199-
let ast_res = ast_a.migrate(&ast_b);
200-
201-
assert_eq!(ast_res.unwrap().to_string(), sql_res);
226+
run_test_cases(
227+
vec![TestCase {
228+
dialect: Dialect::Generic,
229+
sql_a: "CREATE TABLE bar (id INT PRIMARY KEY);",
230+
sql_b: "CREATE TABLE foo (id INT PRIMARY KEY);",
231+
expect:
232+
"CREATE TABLE bar (id INT PRIMARY KEY);\n\nCREATE TABLE foo (id INT PRIMARY KEY);",
233+
}],
234+
|ast_a, ast_b| ast_a.migrate(&ast_b).unwrap(),
235+
);
202236
}
203237

204238
#[test]
205239
fn apply_drop_table() {
206-
let sql_a = "CREATE TABLE bar (id INT PRIMARY KEY)";
207-
let sql_b = "DROP TABLE bar; CREATE TABLE foo (id INT PRIMARY KEY)";
208-
let sql_res = "CREATE TABLE foo (id INT PRIMARY KEY);";
209-
210-
let ast_a = SyntaxTree::builder().sql(sql_a).build().unwrap();
211-
let ast_b = SyntaxTree::builder().sql(sql_b).build().unwrap();
212-
let ast_res = ast_a.migrate(&ast_b);
213-
214-
assert_eq!(ast_res.unwrap().to_string(), sql_res);
240+
run_test_cases(
241+
vec![TestCase {
242+
dialect: Dialect::Generic,
243+
sql_a: "CREATE TABLE bar (id INT PRIMARY KEY)",
244+
sql_b: "DROP TABLE bar; CREATE TABLE foo (id INT PRIMARY KEY)",
245+
expect: "CREATE TABLE foo (id INT PRIMARY KEY);",
246+
}],
247+
|ast_a, ast_b| ast_a.migrate(&ast_b).unwrap(),
248+
);
215249
}
216250

217251
#[test]
218252
fn apply_alter_table_add_column() {
219-
let sql_a = "CREATE TABLE bar (id INT PRIMARY KEY)";
220-
let sql_b = "ALTER TABLE bar ADD COLUMN bar TEXT";
221-
let sql_res = "CREATE TABLE bar (id INT PRIMARY KEY, bar TEXT);";
222-
223-
let ast_a = SyntaxTree::builder().sql(sql_a).build().unwrap();
224-
let ast_b = SyntaxTree::builder().sql(sql_b).build().unwrap();
225-
let ast_res = ast_a.migrate(&ast_b);
226-
227-
assert_eq!(ast_res.unwrap().to_string(), sql_res);
253+
run_test_cases(
254+
vec![TestCase {
255+
dialect: Dialect::Generic,
256+
sql_a: "CREATE TABLE bar (id INT PRIMARY KEY)",
257+
sql_b: "ALTER TABLE bar ADD COLUMN bar TEXT",
258+
expect: "CREATE TABLE bar (id INT PRIMARY KEY, bar TEXT);",
259+
}],
260+
|ast_a, ast_b| ast_a.migrate(&ast_b).unwrap(),
261+
);
228262
}
229263

230264
#[test]
231265
fn apply_alter_table_drop_column() {
232-
let sql_a = "CREATE TABLE bar (bar TEXT, id INT PRIMARY KEY)";
233-
let sql_b = "ALTER TABLE bar DROP COLUMN bar";
234-
let sql_res = "CREATE TABLE bar (id INT PRIMARY KEY);";
235-
236-
let ast_a = SyntaxTree::builder().sql(sql_a).build().unwrap();
237-
let ast_b = SyntaxTree::builder().sql(sql_b).build().unwrap();
238-
let ast_res = ast_a.migrate(&ast_b);
239-
240-
assert_eq!(ast_res.unwrap().to_string(), sql_res);
266+
run_test_cases(
267+
vec![TestCase {
268+
dialect: Dialect::Generic,
269+
sql_a: "CREATE TABLE bar (bar TEXT, id INT PRIMARY KEY)",
270+
sql_b: "ALTER TABLE bar DROP COLUMN bar",
271+
expect: "CREATE TABLE bar (id INT PRIMARY KEY);",
272+
}],
273+
|ast_a, ast_b| ast_a.migrate(&ast_b).unwrap(),
274+
);
241275
}
242276

243277
#[test]
244278
fn apply_alter_table_alter_column() {
245-
#[derive(Debug)]
246-
struct TestCase {
247-
dialect: Dialect,
248-
sql_a: &'static str,
249-
sql_b: &'static str,
250-
expect: &'static str,
251-
}
252-
let test_cases = vec![
279+
run_test_cases(vec![
253280
TestCase {
254281
dialect: Dialect::Generic,
255282
sql_a: "CREATE TABLE bar (bar TEXT, id INT PRIMARY KEY)",
@@ -292,22 +319,6 @@ mod tests {
292319
sql_b: "ALTER TABLE bar ALTER COLUMN bar ADD GENERATED ALWAYS AS IDENTITY (START WITH 10)",
293320
expect: "CREATE TABLE bar (\n bar INTEGER GENERATED ALWAYS AS IDENTITY (START WITH 10),\n id INT PRIMARY KEY\n);",
294321
},
295-
];
296-
297-
test_cases.into_iter().for_each(|tc| {
298-
let ast_a = SyntaxTree::builder()
299-
.dialect(tc.dialect.clone())
300-
.sql(tc.sql_a)
301-
.build()
302-
.unwrap();
303-
let ast_b = SyntaxTree::builder()
304-
.dialect(tc.dialect.clone())
305-
.sql(tc.sql_b)
306-
.build()
307-
.unwrap();
308-
let ast_res = ast_a.migrate(&ast_b);
309-
310-
assert_eq!(ast_res.unwrap().to_string(), tc.expect, "{tc:?}");
311-
});
322+
], |ast_a, ast_b| ast_a.migrate(&ast_b).unwrap());
312323
}
313324
}

0 commit comments

Comments
 (0)