@@ -1,61 +1,45 @@
1−use reshape::migrations::{
2− AddIndex, AlterColumn, ColumnBuilder, ColumnChanges, CreateTableBuilder, Index, Migration,
3−};
4−
51mod common;
2+use common::Test;
63
74#[test]
85fn alter_column_data() {
9− let (mut reshape, mut old_db, mut new_db) = common::setup();
10−
11− let create_users_table = Migration::new("create_user_table", None).with_action(
12− CreateTableBuilder::default()
13− .name("users")
14− .primary_key(vec!["id".to_string()])
15− .columns(vec![
16− ColumnBuilder::default()
17− .name("id")
18− .data_type("INTEGER")
19− .build()
20− .unwrap(),
21− ColumnBuilder::default()
22− .name("name")
23− .data_type("TEXT")
24− .build()
25− .unwrap(),
26− ])
27− .build()
28− .unwrap(),
29− );
30− let uppercase_name = Migration::new("uppercase_name", None).with_action(AlterColumn {
31− table: "users".to_string(),
32− column: "name".to_string(),
33− up: Some("UPPER(name)".to_string()),
34− down: Some("LOWER(name)".to_string()),
35− changes: ColumnChanges {
36− data_type: None,
37− nullable: None,
38− name: None,
39− default: None,
40− },
41− });
6+ let mut test = Test::new("Alter column");
427
43− let first_migrations = vec![create_users_table.clone()];
44− let second_migrations = vec![create_users_table.clone(), uppercase_name.clone()];
8+ test.first_migration(
9+ r#"
10+ name = "create_user_table"
4511
46− // Run first migration, should automatically finish
47− reshape.migrate(first_migrations.clone()).unwrap();
12+ [[actions]]
13+ type = "create_table"
14+ name = "users"
15+ primary_key = ["id"]
4816
49− // Update search paths
50− old_db
51− .simple_query(&reshape::schema_query_for_migration(
52− &first_migrations.last().unwrap().name,
53− ))
54− .unwrap();
17+ [[actions.columns]]
18+ name = "id"
19+ type = "INTEGER"
20+
21+ [[actions.columns]]
22+ name = "name"
23+ type = "TEXT"
24+ "#,
25+ );
5526
56− // Insert some test users
57− old_db
58− .simple_query(
27+ test.second_migration(
28+ r#"
29+ name = "uppercase_name"
30+
31+ [[actions]]
32+ type = "alter_column"
33+ table = "users"
34+ column = "name"
35+ up = "UPPER(name)"
36+ down = "LOWER(name)"
37+ "#,
38+ );
39+
40+ test.after_first(|db| {
41+ // Insert some test users
42+ db.simple_query(
5943 "
6044 INSERT INTO users (id, name) VALUES
6145 (1, 'john Doe'),
@@ -63,98 +47,82 @@ fn alter_column_data() {
6347 ",
6448 )
6549 .unwrap();
50+ });
6651
67− // Run second migration
68− reshape.migrate(second_migrations.clone()).unwrap();
69− new_db
70− .simple_query(&reshape::schema_query_for_migration(
71− &second_migrations.last().unwrap().name,
72− ))
73− .unwrap();
74−
75− // Check that the existing users has the altered data
76− let expected = vec!["JOHN DOE", "JANE DOE"];
77− assert!(new_db
78− .query("SELECT name FROM users ORDER BY id", &[],)
79− .unwrap()
80− .iter()
81− .map(|row| row.get::<_, String>("name"))
82− .eq(expected));
83−
84− // Insert data using old schema and make sure the new schema gets correct values
85− old_db
86− .simple_query("INSERT INTO users (id, name) VALUES (3, 'test testsson')")
87− .unwrap();
88− let result = new_db
89− .query_one("SELECT name from users WHERE id = 3", &[])
90− .unwrap();
91− assert_eq!("TEST TESTSSON", result.get::<_, &str>("name"));
92−
93− // Insert data using new schema and make sure the old schema gets correct values
94− new_db
95− .simple_query("INSERT INTO users (id, name) VALUES (4, 'TEST TESTSSON')")
96− .unwrap();
97− let result = old_db
98− .query_one("SELECT name from users WHERE id = 4", &[])
99− .unwrap();
100− assert_eq!("test testsson", result.get::<_, &str>("name"));
52+ test.intermediate(|old_db, new_db| {
53+ // Check that the existing users has the altered data
54+ let expected = vec!["JOHN DOE", "JANE DOE"];
55+ assert!(new_db
56+ .query("SELECT name FROM users ORDER BY id", &[],)
57+ .unwrap()
58+ .iter()
59+ .map(|row| row.get::<_, String>("name"))
60+ .eq(expected));
61+
62+ // Insert data using old schema and make sure the new schema gets correct values
63+ old_db
64+ .simple_query("INSERT INTO users (id, name) VALUES (3, 'test testsson')")
65+ .unwrap();
66+ let result = new_db
67+ .query_one("SELECT name from users WHERE id = 3", &[])
68+ .unwrap();
69+ assert_eq!("TEST TESTSSON", result.get::<_, &str>("name"));
70+
71+ // Insert data using new schema and make sure the old schema gets correct values
72+ new_db
73+ .simple_query("INSERT INTO users (id, name) VALUES (4, 'TEST TESTSSON')")
74+ .unwrap();
75+ let result = old_db
76+ .query_one("SELECT name from users WHERE id = 4", &[])
77+ .unwrap();
78+ assert_eq!("test testsson", result.get::<_, &str>("name"));
79+ });
10180
102− reshape.complete().unwrap();
103− common::assert_cleaned_up(&mut new_db);
81+ test.run();
10482}
10583
10684#[test]
10785fn alter_column_set_not_null() {
108− let (mut reshape, mut old_db, mut new_db) = common::setup();
109−
110− let create_users_table = Migration::new("create_user_table", None).with_action(
111− CreateTableBuilder::default()
112− .name("users")
113− .primary_key(vec!["id".to_string()])
114− .columns(vec![
115− ColumnBuilder::default()
116− .name("id")
117− .data_type("INTEGER")
118− .build()
119− .unwrap(),
120− ColumnBuilder::default()
121− .name("name")
122− .data_type("TEXT")
123− .build()
124− .unwrap(),
125− ])
126− .build()
127− .unwrap(),
86+ let mut test = Test::new("Set column not null");
87+
88+ test.first_migration(
89+ r#"
90+ name = "create_user_table"
91+
92+ [[actions]]
93+ type = "create_table"
94+ name = "users"
95+ primary_key = ["id"]
96+
97+ [[actions.columns]]
98+ name = "id"
99+ type = "INTEGER"
100+
101+ [[actions.columns]]
102+ name = "name"
103+ type = "TEXT"
104+ "#,
128105 );
129− let set_name_not_null = Migration::new("set_name_not_null", None).with_action(AlterColumn {
130− table: "users".to_string(),
131− column: "name".to_string(),
132− up: Some("COALESCE(name, 'TEST_DEFAULT_VALUE')".to_string()),
133− down: Some("name".to_string()),
134− changes: ColumnChanges {
135− data_type: None,
136− nullable: Some(false),
137− name: None,
138− default: None,
139− },
140− });
141106
142− let first_migrations = vec![create_users_table.clone()];
143− let second_migrations = vec![create_users_table.clone(), set_name_not_null.clone()];
107+ test.second_migration(
108+ r#"
109+ name = "set_name_not_null"
144110
145− // Run first migration, should automatically finish
146− reshape.migrate(first_migrations.clone()).unwrap();
111+ [[actions]]
112+ type = "alter_column"
113+ table = "users"
114+ column = "name"
115+ up = "COALESCE(name, 'TEST_DEFAULT_VALUE')"
116+ down = "name"
147117
148− // Update search paths
149− old_db
150− .simple_query(&reshape::schema_query_for_migration(
151− &first_migrations.last().unwrap().name,
152− ))
153− .unwrap();
118+ [actions.changes]
119+ nullable = false
120+ "#,
121+ );
154122
155− // Insert some test users
156− old_db
157− .simple_query(
123+ test.after_first(|db| {
124+ // Insert some test users
125+ db.simple_query(
158126 "
159127 INSERT INTO users (id, name) VALUES
160128 (1, 'John Doe'),
@@ -162,99 +130,80 @@ fn alter_column_set_not_null() {
162130 ",
163131 )
164132 .unwrap();
133+ });
165134
166− // Run second migration
167− reshape.migrate(second_migrations.clone()).unwrap();
168− new_db
169− .simple_query(&reshape::schema_query_for_migration(
170− &second_migrations.last().unwrap().name,
171− ))
172− .unwrap();
173−
174− // Check that existing users got the correct values
175− let expected = vec!["John Doe", "TEST_DEFAULT_VALUE"];
176− assert!(new_db
177− .query("SELECT name FROM users ORDER BY id", &[],)
178− .unwrap()
179− .iter()
180− .map(|row| row.get::<_, String>("name"))
181− .eq(expected));
182−
183− // Insert data using old schema and make sure the new schema gets correct values
184− old_db
185− .simple_query("INSERT INTO users (id, name) VALUES (3, NULL)")
186− .unwrap();
187− let result = new_db
188− .query_one("SELECT name from users WHERE id = 3", &[])
189− .unwrap();
190− assert_eq!("TEST_DEFAULT_VALUE", result.get::<_, &str>("name"));
191−
192− // Insert data using new schema and make sure the old schema gets correct values
193− new_db
194− .simple_query("INSERT INTO users (id, name) VALUES (4, 'Jane Doe')")
195− .unwrap();
196− let result = old_db
197− .query_one("SELECT name from users WHERE id = 4", &[])
198− .unwrap();
199− assert_eq!("Jane Doe", result.get::<_, &str>("name"));
135+ test.intermediate(|old_db, new_db| {
136+ // Check that existing users got the correct values
137+ let expected = vec!["John Doe", "TEST_DEFAULT_VALUE"];
138+ assert!(new_db
139+ .query("SELECT name FROM users ORDER BY id", &[],)
140+ .unwrap()
141+ .iter()
142+ .map(|row| row.get::<_, String>("name"))
143+ .eq(expected));
144+
145+ // Insert data using old schema and make sure the new schema gets correct values
146+ old_db
147+ .simple_query("INSERT INTO users (id, name) VALUES (3, NULL)")
148+ .unwrap();
149+ let result = new_db
150+ .query_one("SELECT name from users WHERE id = 3", &[])
151+ .unwrap();
152+ assert_eq!("TEST_DEFAULT_VALUE", result.get::<_, &str>("name"));
153+
154+ // Insert data using new schema and make sure the old schema gets correct values
155+ new_db
156+ .simple_query("INSERT INTO users (id, name) VALUES (4, 'Jane Doe')")
157+ .unwrap();
158+ let result = old_db
159+ .query_one("SELECT name from users WHERE id = 4", &[])
160+ .unwrap();
161+ assert_eq!("Jane Doe", result.get::<_, &str>("name"));
162+ });
200163
201− reshape.complete().unwrap();
202− common::assert_cleaned_up(&mut new_db);
164+ test.run();
203165}
204166
205167#[test]
206168fn alter_column_rename() {
207− let (mut reshape, mut old_db, mut new_db) = common::setup();
208−
209− let create_users_table = Migration::new("create_user_table", None).with_action(
210− CreateTableBuilder::default()
211− .name("users")
212− .primary_key(vec!["id".to_string()])
213− .columns(vec![
214− ColumnBuilder::default()
215− .name("id")
216− .data_type("INTEGER")
217− .build()
218− .unwrap(),
219− ColumnBuilder::default()
220− .name("name")
221− .data_type("TEXT")
222− .build()
223− .unwrap(),
224− ])
225− .build()
226− .unwrap(),
169+ let mut test = Test::new("Rename column");
170+
171+ test.first_migration(
172+ r#"
173+ name = "create_user_table"
174+
175+ [[actions]]
176+ type = "create_table"
177+ name = "users"
178+ primary_key = ["id"]
179+
180+ [[actions.columns]]
181+ name = "id"
182+ type = "INTEGER"
183+
184+ [[actions.columns]]
185+ name = "name"
186+ type = "TEXT"
187+ "#,
188+ );
189+
190+ test.second_migration(
191+ r#"
192+ name = "set_name_not_null"
193+
194+ [[actions]]
195+ type = "alter_column"
196+ table = "users"
197+ column = "name"
198+
199+ [actions.changes]
200+ name = "full_name"
201+ "#,
227202 );
228− let rename_to_full_name =
229− Migration::new("rename_to_full_name", None).with_action(AlterColumn {
230− table: "users".to_string(),
231− column: "name".to_string(),
232− up: None, // up and down are not required when only renaming a column
233− down: None,
234− changes: ColumnChanges {
235− data_type: None,
236− nullable: None,
237− name: Some("full_name".to_string()),
238− default: None,
239− },
240− });
241−
242− let first_migrations = vec![create_users_table.clone()];
243− let second_migrations = vec![create_users_table.clone(), rename_to_full_name.clone()];
244−
245− // Run first migration, should automatically finish
246− reshape.migrate(first_migrations.clone()).unwrap();
247−
248− // Update search paths
249− old_db
250− .simple_query(&reshape::schema_query_for_migration(
251− &first_migrations.last().unwrap().name,
252− ))
253− .unwrap();
254203
255− // Insert some test data
256− old_db
257− .simple_query(
204+ test.after_first(|db| {
205+ // Insert some test data
206+ db.simple_query(
258207 "
259208 INSERT INTO users (id, name) VALUES
260209 (1, 'John Doe'),
@@ -262,94 +211,69 @@ fn alter_column_rename() {
262211 ",
263212 )
264213 .unwrap();
214+ });
265215
266− // Run second migration
267− reshape.migrate(second_migrations.clone()).unwrap();
268− new_db
269− .simple_query(&reshape::schema_query_for_migration(
270− &second_migrations.last().unwrap().name,
271− ))
272− .unwrap();
216+ test.intermediate(|_, new_db| {
217+ // Check that existing values can be queried using new column name
218+ let expected = vec!["John Doe", "Jane Doe"];
219+ assert!(new_db
220+ .query("SELECT full_name FROM users ORDER BY id", &[],)
221+ .unwrap()
222+ .iter()
223+ .map(|row| row.get::<_, String>("full_name"))
224+ .eq(expected));
225+ });
273226
274− // Check that existing values can be queried using new column name
275− let expected = vec!["John Doe", "Jane Doe"];
276− assert!(new_db
277− .query("SELECT full_name FROM users ORDER BY id", &[],)
278− .unwrap()
279− .iter()
280− .map(|row| row.get::<_, String>("full_name"))
281− .eq(expected));
282−
283− reshape.complete().unwrap();
284− common::assert_cleaned_up(&mut new_db);
227+ test.run();
285228}
286229
287230#[test]
288231fn alter_column_multiple() {
289− let (mut reshape, mut old_db, mut new_db) = common::setup();
290−
291− let create_users_table = Migration::new("create_user_table", None).with_action(
292− CreateTableBuilder::default()
293− .name("users")
294− .primary_key(vec!["id".to_string()])
295− .columns(vec![
296− ColumnBuilder::default()
297− .name("id")
298− .data_type("INTEGER")
299− .build()
300− .unwrap(),
301− ColumnBuilder::default()
302− .name("counter")
303− .data_type("INTEGER")
304− .nullable(false)
305− .build()
306− .unwrap(),
307− ])
308− .build()
309− .unwrap(),
232+ let mut test = Test::new("Alter column value multiple times");
233+
234+ test.first_migration(
235+ r#"
236+ name = "create_user_table"
237+
238+ [[actions]]
239+ type = "create_table"
240+ name = "users"
241+ primary_key = ["id"]
242+
243+ [[actions.columns]]
244+ name = "id"
245+ type = "INTEGER"
246+
247+ [[actions.columns]]
248+ name = "counter"
249+ type = "INTEGER"
250+ nullable = false
251+ "#,
252+ );
253+
254+ test.second_migration(
255+ r#"
256+ name = "increment_counter_twice"
257+
258+ [[actions]]
259+ type = "alter_column"
260+ table = "users"
261+ column = "counter"
262+ up = "counter + 1"
263+ down = "counter - 1"
264+
265+ [[actions]]
266+ type = "alter_column"
267+ table = "users"
268+ column = "counter"
269+ up = "counter + 1"
270+ down = "counter - 1"
271+ "#,
310272 );
311− let increment_counter_twice = Migration::new("increment_counter_twice", None)
312− .with_action(AlterColumn {
313− table: "users".to_string(),
314− column: "counter".to_string(),
315− up: Some("counter + 1".to_string()),
316− down: Some("counter - 1".to_string()),
317− changes: ColumnChanges {
318− data_type: None,
319− nullable: None,
320− name: None,
321− default: None,
322− },
323− })
324− .with_action(AlterColumn {
325− table: "users".to_string(),
326− column: "counter".to_string(),
327− up: Some("counter + 1".to_string()),
328− down: Some("counter - 1".to_string()),
329− changes: ColumnChanges {
330− data_type: None,
331− nullable: None,
332− name: None,
333− default: None,
334− },
335− });
336−
337− let first_migrations = vec![create_users_table.clone()];
338− let second_migrations = vec![create_users_table.clone(), increment_counter_twice.clone()];
339−
340− // Run first migration, should automatically finish
341− reshape.migrate(first_migrations.clone()).unwrap();
342−
343− // Update search paths
344− old_db
345− .simple_query(&reshape::schema_query_for_migration(
346− &first_migrations.last().unwrap().name,
347− ))
348− .unwrap();
349273
350− // Insert some test data
351− old_db
352− .simple_query(
274+ test.after_first(|db| {
275+ // Insert some test data
276+ db.simple_query(
353277 "
354278 INSERT INTO users (id, counter) VALUES
355279 (1, 0),
@@ -357,239 +281,196 @@ fn alter_column_multiple() {
357281 ",
358282 )
359283 .unwrap();
284+ });
360285
361− // Run second migration
362− reshape.migrate(second_migrations.clone()).unwrap();
363− new_db
364− .simple_query(&reshape::schema_query_for_migration(
365− &second_migrations.last().unwrap().name,
366− ))
367− .unwrap();
368−
369− // Check that the existing data has been updated
370− let expected = vec![2, 102];
371− let results: Vec<i32> = new_db
372− .query("SELECT counter FROM users ORDER BY id", &[])
373− .unwrap()
374− .iter()
375− .map(|row| row.get::<_, i32>("counter"))
376− .collect();
377− assert_eq!(expected, results);
378−
379− // Update data using old schema and make sure it was updated for the new schema
380− old_db
381− .query("UPDATE users SET counter = 50 WHERE id = 1", &[])
382− .unwrap();
383− let result: i32 = new_db
384− .query("SELECT counter FROM users WHERE id = 1", &[])
385− .unwrap()
386− .iter()
387− .map(|row| row.get("counter"))
388− .nth(0)
389− .unwrap();
390− assert_eq!(52, result);
391−
392− // Update data using new schema and make sure it was updated for the old schema
393− new_db
394− .query("UPDATE users SET counter = 50 WHERE id = 1", &[])
395− .unwrap();
396− let result: i32 = old_db
397− .query("SELECT counter FROM users WHERE id = 1", &[])
398− .unwrap()
399− .iter()
400− .map(|row| row.get("counter"))
401− .nth(0)
402− .unwrap();
403− assert_eq!(48, result);
286+ test.intermediate(|old_db, new_db| {
287+ // Check that the existing data has been updated
288+ let expected = vec![2, 102];
289+ let results: Vec<i32> = new_db
290+ .query("SELECT counter FROM users ORDER BY id", &[])
291+ .unwrap()
292+ .iter()
293+ .map(|row| row.get::<_, i32>("counter"))
294+ .collect();
295+ assert_eq!(expected, results);
296+
297+ // Update data using old schema and make sure it was updated for the new schema
298+ old_db
299+ .query("UPDATE users SET counter = 50 WHERE id = 1", &[])
300+ .unwrap();
301+ let result: i32 = new_db
302+ .query("SELECT counter FROM users WHERE id = 1", &[])
303+ .unwrap()
304+ .iter()
305+ .map(|row| row.get("counter"))
306+ .nth(0)
307+ .unwrap();
308+ assert_eq!(52, result);
309+
310+ // Update data using new schema and make sure it was updated for the old schema
311+ new_db
312+ .query("UPDATE users SET counter = 50 WHERE id = 1", &[])
313+ .unwrap();
314+ let result: i32 = old_db
315+ .query("SELECT counter FROM users WHERE id = 1", &[])
316+ .unwrap()
317+ .iter()
318+ .map(|row| row.get("counter"))
319+ .nth(0)
320+ .unwrap();
321+ assert_eq!(48, result);
322+ });
404323
405− reshape.complete().unwrap();
406− common::assert_cleaned_up(&mut new_db);
324+ test.run();
407325}
408326
409327#[test]
410328fn alter_column_default() {
411− let (mut reshape, mut old_db, mut new_db) = common::setup();
412−
413− let create_users_table = Migration::new("create_user_table", None).with_action(
414− CreateTableBuilder::default()
415− .name("users")
416− .primary_key(vec!["id".to_string()])
417− .columns(vec![
418− ColumnBuilder::default()
419− .name("id")
420− .data_type("INTEGER")
421− .build()
422− .unwrap(),
423− ColumnBuilder::default()
424− .name("name")
425− .data_type("TEXT")
426− .nullable(false)
427− .default_value("'DEFAULT'")
428− .build()
429− .unwrap(),
430− ])
431− .build()
432− .unwrap(),
329+ let mut test = Test::new("Change default value for column");
330+
331+ test.first_migration(
332+ r#"
333+ name = "create_user_table"
334+
335+ [[actions]]
336+ type = "create_table"
337+ name = "users"
338+ primary_key = ["id"]
339+
340+ [[actions.columns]]
341+ name = "id"
342+ type = "INTEGER"
343+
344+ [[actions.columns]]
345+ name = "name"
346+ type = "TEXT"
347+ nullable = false
348+ default = "'DEFAULT'"
349+ "#,
433350 );
434− let change_name_default =
435− Migration::new("change_name_default", None).with_action(AlterColumn {
436− table: "users".to_string(),
437− column: "name".to_string(),
438− up: None,
439− down: None,
440− changes: ColumnChanges {
441− data_type: None,
442− nullable: None,
443− name: None,
444− default: Some("'NEW DEFAULT'".to_string()),
445− },
446− });
447−
448− let first_migrations = vec![create_users_table.clone()];
449− let second_migrations = vec![create_users_table.clone(), change_name_default.clone()];
450−
451− // Run first migration, should automatically finish
452− reshape.migrate(first_migrations.clone()).unwrap();
453−
454− // Update search paths
455− old_db
456− .simple_query(&reshape::schema_query_for_migration(
457− &first_migrations.last().unwrap().name,
458− ))
459− .unwrap();
460351
461− // Insert a test user
462− old_db
463− .simple_query(
352+ test.second_migration(
353+ r#"
354+ name = "change_name_default"
355+
356+ [[actions]]
357+ type = "alter_column"
358+ table = "users"
359+ column = "name"
360+
361+ [actions.changes]
362+ default = "'NEW DEFAULT'"
363+ "#,
364+ );
365+
366+ test.after_first(|db| {
367+ // Insert a test user
368+ db.simple_query(
464369 "
465370 INSERT INTO users (id) VALUES (1)
466371 ",
467372 )
468373 .unwrap();
374+ });
469375
470− // Run second migration
471− reshape.migrate(second_migrations.clone()).unwrap();
472− new_db
473− .simple_query(&reshape::schema_query_for_migration(
474− &second_migrations.last().unwrap().name,
475− ))
476− .unwrap();
477−
478− // Check that the existing users has the old default value
479− let expected = vec!["DEFAULT"];
480− assert!(new_db
481− .query("SELECT name FROM users", &[],)
482− .unwrap()
483− .iter()
484− .map(|row| row.get::<_, String>("name"))
485− .eq(expected));
486−
487− // Insert data using old schema and make those get the old default value
488− old_db
489− .simple_query("INSERT INTO users (id) VALUES (2)")
490− .unwrap();
491− let result = new_db
492− .query_one("SELECT name from users WHERE id = 2", &[])
493− .unwrap();
494− assert_eq!("DEFAULT", result.get::<_, &str>("name"));
495−
496− // Insert data using new schema and make sure it gets the new default value
497− new_db
498− .simple_query("INSERT INTO users (id) VALUES (3)")
499− .unwrap();
500− let result = old_db
501− .query_one("SELECT name from users WHERE id = 3", &[])
502− .unwrap();
503− assert_eq!("NEW DEFAULT", result.get::<_, &str>("name"));
376+ test.intermediate(|old_db, new_db| {
377+ // Check that the existing users has the old default value
378+ let expected = vec!["DEFAULT"];
379+ assert!(new_db
380+ .query("SELECT name FROM users", &[],)
381+ .unwrap()
382+ .iter()
383+ .map(|row| row.get::<_, String>("name"))
384+ .eq(expected));
385+
386+ // Insert data using old schema and make those get the old default value
387+ old_db
388+ .simple_query("INSERT INTO users (id) VALUES (2)")
389+ .unwrap();
390+ let result = new_db
391+ .query_one("SELECT name from users WHERE id = 2", &[])
392+ .unwrap();
393+ assert_eq!("DEFAULT", result.get::<_, &str>("name"));
394+
395+ // Insert data using new schema and make sure it gets the new default value
396+ new_db
397+ .simple_query("INSERT INTO users (id) VALUES (3)")
398+ .unwrap();
399+ let result = old_db
400+ .query_one("SELECT name from users WHERE id = 3", &[])
401+ .unwrap();
402+ assert_eq!("NEW DEFAULT", result.get::<_, &str>("name"));
403+ });
504404
505− reshape.complete().unwrap();
506− common::assert_cleaned_up(&mut new_db);
405+ test.run();
507406}
508407
509408#[test]
510409fn alter_column_with_index() {
511− let (mut reshape, mut db, _) = common::setup();
512−
513− let create_users_table = Migration::new("create_user_table", None)
514− .with_action(
515− CreateTableBuilder::default()
516− .name("users")
517− .primary_key(vec!["id".to_string()])
518− .columns(vec![
519− ColumnBuilder::default()
520− .name("id")
521− .data_type("INTEGER")
522− .build()
523− .unwrap(),
524− ColumnBuilder::default()
525− .name("first_name")
526− .data_type("TEXT")
527− .build()
528− .unwrap(),
529− ColumnBuilder::default()
530− .name("last_name")
531− .data_type("TEXT")
532− .build()
533− .unwrap(),
534− ])
535− .build()
536− .unwrap(),
537− )
538− .with_action(AddIndex {
539− table: "users".to_string(),
540− index: Index {
541− name: "users_name_idx".to_string(),
542− columns: vec!["first_name".to_string(), "last_name".to_string()],
543− unique: false,
544− index_type: None,
545− },
546− });
547− let uppercase_name = Migration::new("uppercase_name", None).with_action(AlterColumn {
548− table: "users".to_string(),
549− column: "last_name".to_string(),
550− up: Some("UPPER(last_name)".to_string()),
551− down: Some("LOWER(last_name)".to_string()),
552− changes: ColumnChanges {
553− data_type: None,
554− nullable: None,
555− name: None,
556− default: None,
557− },
558− });
410+ let mut test = Test::new("Alter column with index");
559411
560− let first_migrations = vec![create_users_table.clone()];
561− let second_migrations = vec![create_users_table.clone(), uppercase_name.clone()];
412+ test.first_migration(
413+ r#"
414+ name = "create_user_table"
562415
563− // Run first migration, should automatically finish
564− reshape.migrate(first_migrations.clone()).unwrap();
416+ [[actions]]
417+ type = "create_table"
418+ name = "users"
419+ primary_key = ["id"]
565420
566− // Run second migration
567− reshape.migrate(second_migrations.clone()).unwrap();
568− db.simple_query(&reshape::schema_query_for_migration(
569− &second_migrations.last().unwrap().name,
570− ))
571− .unwrap();
421+ [[actions.columns]]
422+ name = "id"
423+ type = "INTEGER"
572424
573− // Complete the second migration which should replace the existing column
574− // with the temporary one
575− reshape.complete().unwrap();
425+ [[actions.columns]]
426+ name = "first_name"
427+ type = "TEXT"
576428
577− // Make sure index still exists
578− let result: i64 = db
579− .query(
580− "
429+ [[actions.columns]]
430+ name = "last_name"
431+ type = "TEXT"
432+
433+ [[actions]]
434+ type = "add_index"
435+ table = "users"
436+
437+ [actions.index]
438+ name = "users_name_idx"
439+ columns = ["first_name", "last_name"]
440+ "#,
441+ );
442+
443+ test.second_migration(
444+ r#"
445+ name = "uppercase_last_name"
446+
447+ [[actions]]
448+ type = "alter_column"
449+ table = "users"
450+ column = "last_name"
451+ up = "UPPER(last_name)"
452+ down = "LOWER(last_name)"
453+ "#,
454+ );
455+
456+ test.after_completion(|db| {
457+ // Make sure index still exists
458+ let result: i64 = db
459+ .query(
460+ "
581461 SELECT COUNT(*)
582462 FROM pg_catalog.pg_index
583463 JOIN pg_catalog.pg_class ON pg_index.indexrelid = pg_class.oid
584464 WHERE pg_class.relname = 'users_name_idx'
585465 ",
586− &[],
587− )
588− .unwrap()
589− .first()
590− .map(|row| row.get(0))
591− .unwrap();
592− assert_eq!(1, result, "expected index to still exist");
466+ &[],
467+ )
468+ .unwrap()
469+ .first()
470+ .map(|row| row.get(0))
471+ .unwrap();
472+ assert_eq!(1, result, "expected index to still exist");
473+ });
593474
594− common::assert_cleaned_up(&mut db);
475+ test.run();
595476}