diff --git a/test/integration/001_simple_copy_test/test_simple_copy.py b/test/integration/001_simple_copy_test/test_simple_copy.py index 8733126d786..aec73a3dad0 100644 --- a/test/integration/001_simple_copy_test/test_simple_copy.py +++ b/test/integration/001_simple_copy_test/test_simple_copy.py @@ -24,16 +24,20 @@ def test__postgres__simple_copy(self): self.use_profile("postgres") self.use_default_project({"data-paths": [self.dir("seed-initial")]}) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt() + self.assertEqual(len(results), 6) self.assertTablesEqual("seed","view_model") self.assertTablesEqual("seed","incremental") self.assertTablesEqual("seed","materialized") self.use_default_project({"data-paths": [self.dir("seed-update")]}) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt() + self.assertEqual(len(results), 6) self.assertTablesEqual("seed","view_model") self.assertTablesEqual("seed","incremental") @@ -44,8 +48,10 @@ def test__postgres__dbt_doesnt_run_empty_models(self): self.use_profile("postgres") self.use_default_project({"data-paths": [self.dir("seed-initial")]}) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt() + self.assertEqual(len(results), 6) models = self.get_models_in_schema() @@ -80,8 +86,10 @@ def test__snowflake__simple_copy__quoting_on(self): "quoting": {"identifier": True}, }) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt() + self.assertEqual(len(results), 6) self.assertTablesEqual("seed", "view_model") self.assertTablesEqual("seed", "incremental") @@ -91,8 +99,10 @@ def test__snowflake__simple_copy__quoting_on(self): "data-paths": [self.dir("seed-update")], "quoting": {"identifier": True}, }) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt() + self.assertEqual(len(results), 6) self.assertTablesEqual("seed", "view_model") self.assertTablesEqual("seed", "incremental") @@ -106,8 +116,10 @@ def test__snowflake__simple_copy__quoting_off(self): "quoting": {"identifier": False}, }) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt() + self.assertEqual(len(results), 6) self.assertTablesEqual("SEED", "VIEW_MODEL") self.assertTablesEqual("SEED", "INCREMENTAL") @@ -117,8 +129,10 @@ def test__snowflake__simple_copy__quoting_off(self): "data-paths": [self.dir("seed-update")], "quoting": {"identifier": False}, }) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt() + self.assertEqual(len(results), 6) self.assertTablesEqual("SEED", "VIEW_MODEL") self.assertTablesEqual("SEED", "INCREMENTAL") @@ -132,10 +146,11 @@ def test__snowflake__seed__quoting_switch(self): "quoting": {"identifier": False}, }) - self.run_dbt(["seed"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) self.use_default_project({ "data-paths": [self.dir("seed-update")], "quoting": {"identifier": True}, }) - self.run_dbt(["seed"], expect_pass=False) + results = self.run_dbt(["seed"], expect_pass=False) diff --git a/test/integration/002_varchar_widening_test/test_varchar_widening.py b/test/integration/002_varchar_widening_test/test_varchar_widening.py index e53a5d5ea0f..c3556d59be5 100644 --- a/test/integration/002_varchar_widening_test/test_varchar_widening.py +++ b/test/integration/002_varchar_widening_test/test_varchar_widening.py @@ -20,14 +20,16 @@ def test__postgres__varchar_widening(self): self.use_default_project() self.run_sql_file("test/integration/002_varchar_widening_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 2) self.assertTablesEqual("seed","incremental") self.assertTablesEqual("seed","materialized") self.run_sql_file("test/integration/002_varchar_widening_test/update.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 2) self.assertTablesEqual("seed","incremental") self.assertTablesEqual("seed","materialized") @@ -38,14 +40,16 @@ def test__snowflake__varchar_widening(self): self.use_default_project() self.run_sql_file("test/integration/002_varchar_widening_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 2) self.assertTablesEqual("SEED", "incremental") self.assertTablesEqual("SEED", "materialized") self.run_sql_file("test/integration/002_varchar_widening_test/update.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 2) self.assertTablesEqual("SEED", "incremental") self.assertTablesEqual("SEED", "materialized") diff --git a/test/integration/003_simple_reference_test/test_simple_reference.py b/test/integration/003_simple_reference_test/test_simple_reference.py index 2f0ab0a6916..a3e967779c0 100644 --- a/test/integration/003_simple_reference_test/test_simple_reference.py +++ b/test/integration/003_simple_reference_test/test_simple_reference.py @@ -21,7 +21,9 @@ def test__postgres__simple_reference(self): self.run_sql_file( "test/integration/003_simple_reference_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + # ephemeral_copy doesn't show up in results + self.assertEqual(len(results), 7) # Copies should match self.assertTablesEqual("seed","incremental_copy") @@ -36,7 +38,8 @@ def test__postgres__simple_reference(self): self.run_sql_file("test/integration/003_simple_reference_test/update.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 7) # Copies should match self.assertTablesEqual("seed","incremental_copy") @@ -55,7 +58,8 @@ def test__snowflake__simple_reference(self): self.use_default_project() self.run_sql_file("test/integration/003_simple_reference_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 7) # Copies should match self.assertTablesEqual("SEED", "incremental_copy") @@ -71,7 +75,8 @@ def test__snowflake__simple_reference(self): self.run_sql_file( "test/integration/003_simple_reference_test/update.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 7) # Copies should match self.assertTablesEqual("SEED", "incremental_copy") @@ -92,7 +97,10 @@ def test__postgres__simple_reference_with_models(self): # Run materialized_copy, ephemeral_copy, and their dependents # ephemeral_copy should not actually be materialized b/c it is ephemeral - self.run_dbt(['run', '--models', 'materialized_copy', 'ephemeral_copy']) + results = self.run_dbt( + ['run', '--models', 'materialized_copy', 'ephemeral_copy'] + ) + self.assertEqual(len(results), 1) # Copies should match self.assertTablesEqual("seed","materialized_copy") @@ -109,7 +117,10 @@ def test__postgres__simple_reference_with_models_and_children(self): # Run materialized_copy, ephemeral_copy, and their dependents # ephemeral_copy should not actually be materialized b/c it is ephemeral # the dependent ephemeral_summary, however, should be materialized as a table - self.run_dbt(['run', '--models', 'materialized_copy+', 'ephemeral_copy+']) + results = self.run_dbt( + ['run', '--models', 'materialized_copy+', 'ephemeral_copy+'] + ) + self.assertEqual(len(results), 3) # Copies should match self.assertTablesEqual("seed","materialized_copy") @@ -144,7 +155,10 @@ def test__snowflake__simple_reference_with_models(self): # Run materialized_copy & ephemeral_copy # ephemeral_copy should not actually be materialized b/c it is ephemeral - self.run_dbt(['run', '--models', 'materialized_copy', 'ephemeral_copy']) + results = self.run_dbt( + ['run', '--models', 'materialized_copy', 'ephemeral_copy'] + ) + self.assertEqual(len(results), 1) # Copies should match self.assertTablesEqual("SEED", "materialized_copy") @@ -161,7 +175,10 @@ def test__snowflake__simple_reference_with_models_and_children(self): # Run materialized_copy, ephemeral_copy, and their dependents # ephemeral_copy should not actually be materialized b/c it is ephemeral # the dependent ephemeral_summary, however, should be materialized as a table - self.run_dbt(['run', '--models', 'materialized_copy+', 'ephemeral_copy+']) + results = self.run_dbt( + ['run', '--models', 'materialized_copy+', 'ephemeral_copy+'] + ) + self.assertEqual(len(results), 3) # Copies should match self.assertTablesEqual("SEED", "materialized_copy") diff --git a/test/integration/004_simple_archive_test/test_simple_archive.py b/test/integration/004_simple_archive_test/test_simple_archive.py index c2e7a3c3d23..7a50aa458bb 100644 --- a/test/integration/004_simple_archive_test/test_simple_archive.py +++ b/test/integration/004_simple_archive_test/test_simple_archive.py @@ -44,14 +44,16 @@ def test__postgres__simple_archive(self): self.use_default_project() self.run_sql_file("test/integration/004_simple_archive_test/seed.sql") - self.run_dbt(["archive"]) + results = self.run_dbt(["archive"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("archive_expected","archive_actual") self.run_sql_file("test/integration/004_simple_archive_test/invalidate_postgres.sql") self.run_sql_file("test/integration/004_simple_archive_test/update.sql") - self.run_dbt(["archive"]) + results = self.run_dbt(["archive"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("archive_expected","archive_actual") @@ -61,13 +63,15 @@ def test__snowflake__simple_archive(self): self.use_default_project() self.run_sql_file("test/integration/004_simple_archive_test/seed.sql") - self.run_dbt(["archive"]) + results = self.run_dbt(["archive"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("ARCHIVE_EXPECTED", "archive_actual") self.run_sql_file("test/integration/004_simple_archive_test/invalidate_snowflake.sql") self.run_sql_file("test/integration/004_simple_archive_test/update.sql") - self.run_dbt(["archive"]) + results = self.run_dbt(["archive"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("ARCHIVE_EXPECTED", "archive_actual") diff --git a/test/integration/005_simple_seed_test/test_seed_type_override.py b/test/integration/005_simple_seed_test/test_seed_type_override.py index 98f26598693..63e678a8b14 100644 --- a/test/integration/005_simple_seed_test/test_seed_type_override.py +++ b/test/integration/005_simple_seed_test/test_seed_type_override.py @@ -41,9 +41,11 @@ def seed_types(self): } @attr(type='postgres') - def test_simple_seed_with_column_override_snowflake(self): - self.run_dbt(["seed"]) - self.run_dbt(["test"]) + def test_simple_seed_with_column_override_postgres(self): + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt(["test"]) + self.assertEqual(len(results), 2) class TestSimpleSeedColumnOverrideSnowflake(TestSimpleSeedColumnOverride): @@ -63,8 +65,10 @@ def profile_config(self): @attr(type='snowflake') def test_simple_seed_with_column_override_snowflake(self): - self.run_dbt(["seed"]) - self.run_dbt(["test"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt(["test"]) + self.assertEqual(len(results), 2) class TestSimpleSeedColumnOverrideBQ(TestSimpleSeedColumnOverride): @property @@ -83,5 +87,7 @@ def profile_config(self): @attr(type='bigquery') def test_simple_seed_with_column_override_bq(self): - self.run_dbt(["seed"]) - self.run_dbt(["test"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) + results = self.run_dbt(["test"]) + self.assertEqual(len(results), 2) diff --git a/test/integration/005_simple_seed_test/test_simple_seed.py b/test/integration/005_simple_seed_test/test_simple_seed.py index 3f720785f64..a4496a14cf6 100644 --- a/test/integration/005_simple_seed_test/test_simple_seed.py +++ b/test/integration/005_simple_seed_test/test_simple_seed.py @@ -24,21 +24,25 @@ def project_config(self): @attr(type='postgres') def test_simple_seed(self): - self.run_dbt(["seed"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed_actual","seed_expected") # this should truncate the seed_actual table, then re-insert - self.run_dbt(["seed"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed_actual","seed_expected") @attr(type='postgres') def test_simple_seed_with_drop(self): - self.run_dbt(["seed"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed_actual","seed_expected") # this should drop the seed table, then re-create - self.run_dbt(["seed", "--drop-existing"]) + results = self.run_dbt(["seed", "--drop-existing"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed_actual","seed_expected") @@ -69,11 +73,13 @@ def project_config(self): def test_simple_seed_with_schema(self): schema_name = "{}_{}".format(self.unique_schema(), 'custom_schema') - self.run_dbt(["seed"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed_actual","seed_expected", table_a_schema=schema_name) # this should truncate the seed_actual table, then re-insert - self.run_dbt(["seed"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed_actual","seed_expected", table_a_schema=schema_name) @@ -81,11 +87,13 @@ def test_simple_seed_with_schema(self): def test_simple_seed_with_drop_and_schema(self): schema_name = "{}_{}".format(self.unique_schema(), 'custom_schema') - self.run_dbt(["seed"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed_actual","seed_expected", table_a_schema=schema_name) # this should drop the seed table, then re-create - self.run_dbt(["seed", "--full-refresh"]) + results = self.run_dbt(["seed", "--full-refresh"]) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed_actual","seed_expected", table_a_schema=schema_name) @@ -117,6 +125,7 @@ def project_config(self): @attr(type='postgres') def test_simple_seed_with_disabled(self): - self.run_dbt(["seed"]) + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 1) self.assertTableDoesExist('seed_enabled') self.assertTableDoesNotExist('seed_disabled') diff --git a/test/integration/006_simple_dependency_test/test_simple_dependency.py b/test/integration/006_simple_dependency_test/test_simple_dependency.py index e45501976ef..ff84441e962 100644 --- a/test/integration/006_simple_dependency_test/test_simple_dependency.py +++ b/test/integration/006_simple_dependency_test/test_simple_dependency.py @@ -26,7 +26,8 @@ def project_config(self): @attr(type='postgres') def test_simple_dependency(self): self.run_dbt(["deps"]) - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) + self.assertEqual(len(results), 4) self.assertTablesEqual("seed","table_model") self.assertTablesEqual("seed","view_model") @@ -37,7 +38,8 @@ def test_simple_dependency(self): self.run_sql_file("test/integration/006_simple_dependency_test/update.sql") self.run_dbt(["deps"]) - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) + self.assertEqual(len(results), 4) self.assertTablesEqual("seed","table_model") self.assertTablesEqual("seed","view_model") @@ -46,7 +48,8 @@ def test_simple_dependency(self): @attr(type='postgres') def test_simple_dependency_with_models(self): self.run_dbt(["deps"]) - self.run_dbt(["run", '--models', 'view_model+']) + results = self.run_dbt(["run", '--models', 'view_model+']) + self.assertEqual(len(results), 2) self.assertTablesEqual("seed","view_model") self.assertTablesEqual("seed_summary","view_summary") @@ -83,7 +86,8 @@ def project_config(self): def deps_run_assert_equality(self): self.run_dbt(["deps"]) - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) + self.assertEqual(len(results), 4) self.assertTablesEqual("seed","table_model") self.assertTablesEqual("seed","view_model") diff --git a/test/integration/006_simple_dependency_test/test_simple_dependency_with_configs.py b/test/integration/006_simple_dependency_test/test_simple_dependency_with_configs.py index 65627ad72da..eb4ea23cf92 100644 --- a/test/integration/006_simple_dependency_test/test_simple_dependency_with_configs.py +++ b/test/integration/006_simple_dependency_test/test_simple_dependency_with_configs.py @@ -36,7 +36,8 @@ def project_config(self): @attr(type='postgres') def test_simple_dependency(self): self.run_dbt(["deps"]) - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) + self.assertEqual(len(results), 5) self.assertTablesEqual('seed_config_expected_1',"config") self.assertTablesEqual("seed","table_model") @@ -70,7 +71,8 @@ def project_config(self): @attr(type='postgres') def test_simple_dependency(self): self.run_dbt(["deps"]) - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) + self.assertEqual(len(results), 5) self.assertTablesEqual('seed_config_expected_2',"config") self.assertTablesEqual("seed","table_model") @@ -108,7 +110,8 @@ def test_simple_dependency(self): self.use_default_project() self.run_dbt(["deps"]) - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) + self.assertEqual(len(results), 5) self.assertTablesEqual('seed_config_expected_3',"config") self.assertTablesEqual("seed","table_model") @@ -153,7 +156,8 @@ def project_config(self): @attr(type='postgres') def test_simple_dependency(self): self.run_dbt(["deps"]) - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) + self.assertEqual(len(results), 3) self.assertTablesEqual("seed","view_model") self.assertTablesEqual("seed","incremental") diff --git a/test/integration/007_graph_selection_tests/test_graph_selection.py b/test/integration/007_graph_selection_tests/test_graph_selection.py index 6d15d462b56..7f869895fd9 100644 --- a/test/integration/007_graph_selection_tests/test_graph_selection.py +++ b/test/integration/007_graph_selection_tests/test_graph_selection.py @@ -17,7 +17,8 @@ def test__postgres__specific_model(self): self.use_default_project() self.run_sql_file("test/integration/007_graph_selection_tests/seed.sql") - self.run_dbt(['run', '--models', 'users']) + results = self.run_dbt(['run', '--models', 'users']) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed", "users") created_models = self.get_models_in_schema() @@ -31,7 +32,8 @@ def test__snowflake__specific_model(self): self.use_default_project() self.run_sql_file("test/integration/007_graph_selection_tests/seed.sql") - self.run_dbt(['run', '--models', 'users']) + results = self.run_dbt(['run', '--models', 'users']) + self.assertEqual(len(results), 1) self.assertTablesEqual("SEED", "users") created_models = self.get_models_in_schema() @@ -46,7 +48,8 @@ def test__postgres__specific_model_and_children(self): self.use_default_project() self.run_sql_file("test/integration/007_graph_selection_tests/seed.sql") - self.run_dbt(['run', '--models', 'users+']) + results = self.run_dbt(['run', '--models', 'users+']) + self.assertEqual(len(results), 2) self.assertTablesEqual("seed", "users") self.assertTablesEqual("summary_expected", "users_rollup") @@ -60,7 +63,8 @@ def test__snowflake__specific_model_and_children(self): self.use_default_project() self.run_sql_file("test/integration/007_graph_selection_tests/seed.sql") - self.run_dbt(['run', '--models', 'users+']) + results = self.run_dbt(['run', '--models', 'users+']) + self.assertEqual(len(results), 2) self.assertTablesEqual("SEED", "users") self.assertTablesEqual("SUMMARY_EXPECTED", "users_rollup") @@ -75,7 +79,8 @@ def test__postgres__specific_model_and_parents(self): self.use_default_project() self.run_sql_file("test/integration/007_graph_selection_tests/seed.sql") - self.run_dbt(['run', '--models', '+users_rollup']) + results = self.run_dbt(['run', '--models', '+users_rollup']) + self.assertEqual(len(results), 2) self.assertTablesEqual("seed", "users") self.assertTablesEqual("summary_expected", "users_rollup") @@ -89,7 +94,8 @@ def test__snowflake__specific_model_and_parents(self): self.use_default_project() self.run_sql_file("test/integration/007_graph_selection_tests/seed.sql") - self.run_dbt(['run', '--models', '+users_rollup']) + results = self.run_dbt(['run', '--models', '+users_rollup']) + self.assertEqual(len(results), 2) self.assertTablesEqual("SEED", "users") self.assertTablesEqual("SUMMARY_EXPECTED", "users_rollup") @@ -104,7 +110,10 @@ def test__postgres__specific_model_with_exclusion(self): self.use_default_project() self.run_sql_file("test/integration/007_graph_selection_tests/seed.sql") - self.run_dbt(['run', '--models', '+users_rollup', '--exclude', 'users_rollup']) + results = self.run_dbt( + ['run', '--models', '+users_rollup', '--exclude', 'users_rollup'] + ) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed", "users") created_models = self.get_models_in_schema() @@ -118,7 +127,10 @@ def test__snowflake__specific_model_with_exclusion(self): self.use_default_project() self.run_sql_file("test/integration/007_graph_selection_tests/seed.sql") - self.run_dbt(['run', '--models', '+users_rollup', '--exclude', 'users_rollup']) + results = self.run_dbt( + ['run', '--models', '+users_rollup', '--exclude', 'users_rollup'] + ) + self.assertEqual(len(results), 1) self.assertTablesEqual("SEED", "users") created_models = self.get_models_in_schema() diff --git a/test/integration/007_graph_selection_tests/test_schema_test_graph_selection.py b/test/integration/007_graph_selection_tests/test_schema_test_graph_selection.py index c12a856c188..24689daca8f 100644 --- a/test/integration/007_graph_selection_tests/test_schema_test_graph_selection.py +++ b/test/integration/007_graph_selection_tests/test_schema_test_graph_selection.py @@ -30,7 +30,8 @@ def run_schema_and_assert(self, include, exclude, expected_tests): self.run_sql_file("test/integration/007_graph_selection_tests/seed.sql") self.run_dbt(["deps"]) - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 5) args = FakeArgs() args.models = include diff --git a/test/integration/008_schema_tests_test/test_schema_tests.py b/test/integration/008_schema_tests_test/test_schema_tests.py index 8ec45103cd7..49076c77fbf 100644 --- a/test/integration/008_schema_tests_test/test_schema_tests.py +++ b/test/integration/008_schema_tests_test/test_schema_tests.py @@ -29,7 +29,8 @@ def run_schema_validations(self): @attr(type='postgres') def test_schema_tests(self): - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 4) test_results = self.run_schema_validations() for result in test_results: @@ -71,7 +72,8 @@ def run_schema_validations(self): @attr(type='postgres') def test_malformed_schema_test_wont_brick_run(self): # dbt run should work (Despite broken schema test) - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 1) ran_tests = self.run_schema_validations() self.assertEqual(len(ran_tests), 2) @@ -114,7 +116,9 @@ def run_schema_validations(self): @attr(type='postgres') def test_schema_tests(self): self.run_dbt(["deps"]) - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 4) + test_results = self.run_schema_validations() expected_failures = ['unique', 'every_value_is_blue'] diff --git a/test/integration/009_data_tests_test/test_data_tests.py b/test/integration/009_data_tests_test/test_data_tests.py index e296246cf03..3f7504b706a 100644 --- a/test/integration/009_data_tests_test/test_data_tests.py +++ b/test/integration/009_data_tests_test/test_data_tests.py @@ -38,7 +38,8 @@ def test_postgres_data_tests(self): self.run_sql_file("test/integration/009_data_tests_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 1) test_results = self.run_data_validations() for result in test_results: @@ -66,7 +67,8 @@ def test_snowflake_data_tests(self): self.run_sql_file("test/integration/009_data_tests_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 1) test_results = self.run_data_validations() for result in test_results: diff --git a/test/integration/010_permission_tests/test_permissions.py b/test/integration/010_permission_tests/test_permissions.py index 1282aea37a5..34a9ef92007 100644 --- a/test/integration/010_permission_tests/test_permissions.py +++ b/test/integration/010_permission_tests/test_permissions.py @@ -41,4 +41,5 @@ def test_create_schema_permissions(self): self.run_sql('grant usage, create on schema "{}" to noaccess'.format(self.unique_schema())) self.run_sql('grant select on all tables in schema "{}" to noaccess'.format(self.unique_schema())) - self.run_dbt(['run', '--target', 'noaccess']) + results = self.run_dbt(['run', '--target', 'noaccess']) + self.assertEqual(len(results), 1) diff --git a/test/integration/012_profile_config_tests/test_profile_config.py b/test/integration/012_profile_config_tests/test_profile_config.py index c9969020f69..2572871c61f 100644 --- a/test/integration/012_profile_config_tests/test_profile_config.py +++ b/test/integration/012_profile_config_tests/test_profile_config.py @@ -40,7 +40,8 @@ def profile_config(self): @attr(type='postgres') def test_deprecated_run_target_config(self): - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 1) self.assertTablesEqual("seed","view_model") diff --git a/test/integration/013_context_var_tests/test_context_vars.py b/test/integration/013_context_var_tests/test_context_vars.py index 4b92ea480ae..ff3f7c35f3c 100644 --- a/test/integration/013_context_var_tests/test_context_vars.py +++ b/test/integration/013_context_var_tests/test_context_vars.py @@ -86,7 +86,8 @@ def get_ctx_vars(self): @attr(type='postgres') def test_env_vars_dev(self): - self.run_dbt(['run']) + results = self.run_dbt(['run']) + self.assertEqual(len(results), 1) ctx = self.get_ctx_vars() self.assertEqual( @@ -111,7 +112,8 @@ def test_env_vars_dev(self): @attr(type='postgres') def test_env_vars_prod(self): - self.run_dbt(['run', '--target', 'prod']) + results = self.run_dbt(['run', '--target', 'prod']) + self.assertEqual(len(results), 1) ctx = self.get_ctx_vars() self.assertEqual( diff --git a/test/integration/015_cli_invocation_tests/test_cli_invocation.py b/test/integration/015_cli_invocation_tests/test_cli_invocation.py index 825470ccf74..86747b66f9e 100644 --- a/test/integration/015_cli_invocation_tests/test_cli_invocation.py +++ b/test/integration/015_cli_invocation_tests/test_cli_invocation.py @@ -19,14 +19,16 @@ def models(self): @attr(type='postgres') def test_toplevel_dbt_run(self): - self.run_dbt(['run']) + results = self.run_dbt(['run']) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed", "model") @attr(type='postgres') def test_subdir_dbt_run(self): os.chdir(os.path.join(self.models, "subdir1")) - self.run_dbt(['run']) + results = self.run_dbt(['run']) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed", "model") class TestCLIInvocationWithProfilesDir(DBTIntegrationTest): @@ -86,7 +88,8 @@ def models(self): @attr(type='postgres') def test_toplevel_dbt_run_with_profile_dir_arg(self): - self.run_dbt(['run', '--profiles-dir', 'dbt-profile']) + results = self.run_dbt(['run', '--profiles-dir', 'dbt-profile']) + self.assertEqual(len(results), 1) actual = self.run_sql("select id from {}.model".format(self.custom_schema), fetch='one') diff --git a/test/integration/016_macro_tests/test_macros.py b/test/integration/016_macro_tests/test_macros.py index 4f4b2c18e63..f6b6e41d7a8 100644 --- a/test/integration/016_macro_tests/test_macros.py +++ b/test/integration/016_macro_tests/test_macros.py @@ -33,7 +33,8 @@ def project_config(self): @attr(type='postgres') def test_working_macros(self): self.run_dbt(["deps"]) - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) + self.assertEqual(len(results), 6) self.assertTablesEqual("expected_dep_macro", "dep_macro") self.assertTablesEqual("expected_local_macro", "local_macro") diff --git a/test/integration/017_runtime_materialization_tests/test_runtime_materialization.py b/test/integration/017_runtime_materialization_tests/test_runtime_materialization.py index 95f5f136219..8a6b65ac4d0 100644 --- a/test/integration/017_runtime_materialization_tests/test_runtime_materialization.py +++ b/test/integration/017_runtime_materialization_tests/test_runtime_materialization.py @@ -19,7 +19,8 @@ def models(self): @attr(type='postgres') def test_full_refresh(self): # initial full-refresh should have no effect - self.run_dbt(['run', '--full-refresh']) + results = self.run_dbt(['run', '--full-refresh']) + self.assertEqual(len(results), 3) self.assertTablesEqual("seed","view") self.assertTablesEqual("seed","incremental") @@ -27,12 +28,14 @@ def test_full_refresh(self): # adds one record to the incremental model. full-refresh should truncate then re-run self.run_sql_file("test/integration/017_runtime_materialization_tests/invalidate_incremental.sql") - self.run_dbt(['run', '--full-refresh']) + results = self.run_dbt(['run', '--full-refresh']) + self.assertEqual(len(results), 3) self.assertTablesEqual("seed","incremental") self.run_sql_file("test/integration/017_runtime_materialization_tests/update.sql") - self.run_dbt(['run', '--full-refresh']) + results = self.run_dbt(['run', '--full-refresh']) + self.assertEqual(len(results), 3) self.assertTablesEqual("seed","view") self.assertTablesEqual("seed","incremental") @@ -40,7 +43,8 @@ def test_full_refresh(self): @attr(type='postgres') def test_non_destructive(self): - self.run_dbt(['run', '--non-destructive']) + results = self.run_dbt(['run', '--non-destructive']) + self.assertEqual(len(results), 3) self.assertTablesEqual("seed","view") self.assertTablesEqual("seed","incremental") @@ -49,7 +53,8 @@ def test_non_destructive(self): self.run_sql_file("test/integration/017_runtime_materialization_tests/update.sql") - self.run_dbt(['run', '--non-destructive']) + results = self.run_dbt(['run', '--non-destructive']) + self.assertEqual(len(results), 3) self.assertTableDoesExist('dependent_view') self.assertTablesEqual("seed","view") @@ -58,7 +63,8 @@ def test_non_destructive(self): @attr(type='postgres') def test_full_refresh_and_non_destructive(self): - self.run_dbt(['run', '--full-refresh', '--non-destructive']) + results = self.run_dbt(['run', '--full-refresh', '--non-destructive']) + self.assertEqual(len(results), 3) self.assertTablesEqual("seed","view") self.assertTablesEqual("seed","incremental") @@ -68,7 +74,8 @@ def test_full_refresh_and_non_destructive(self): self.run_sql_file("test/integration/017_runtime_materialization_tests/invalidate_incremental.sql") self.run_sql_file("test/integration/017_runtime_materialization_tests/update.sql") - self.run_dbt(['run', '--full-refresh', '--non-destructive']) + results = self.run_dbt(['run', '--full-refresh', '--non-destructive']) + self.assertEqual(len(results), 3) self.assertTableDoesExist('dependent_view') self.assertTablesEqual("seed","view") @@ -80,7 +87,8 @@ def test_full_refresh_and_non_destructive(self): def test_delete__dbt_tmp_relation(self): # This creates a __dbt_tmp view - make sure it doesn't interfere with the dbt run self.run_sql_file("test/integration/017_runtime_materialization_tests/create_view__dbt_tmp.sql") - self.run_dbt(['run', '--model', 'view']) + results = self.run_dbt(['run', '--model', 'view']) + self.assertEqual(len(results), 1) self.assertTableDoesNotExist('view__model_dbt_tmp') self.assertTablesEqual("seed","view") diff --git a/test/integration/018_adapter_ddl_tests/test_adapter_ddl.py b/test/integration/018_adapter_ddl_tests/test_adapter_ddl.py index 87ff63da858..274bc761d13 100644 --- a/test/integration/018_adapter_ddl_tests/test_adapter_ddl.py +++ b/test/integration/018_adapter_ddl_tests/test_adapter_ddl.py @@ -18,6 +18,7 @@ def models(self): @attr(type='postgres') def test_sort_and_dist_keys_are_nops_on_postgres(self): - self.run_dbt(['run']) + results = self.run_dbt(['run']) + self.assertEqual(len(results), 1) self.assertTablesEqual("seed","materialized") diff --git a/test/integration/019_analysis_tests/test_analyses.py b/test/integration/019_analysis_tests/test_analyses.py index 25dcaeda704..2bf49de19d9 100644 --- a/test/integration/019_analysis_tests/test_analyses.py +++ b/test/integration/019_analysis_tests/test_analyses.py @@ -25,7 +25,8 @@ def project_config(self): @attr(type='postgres') def test_analyses(self): - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) + self.assertEqual(len(results), 1) compiled_analysis_path = os.path.normpath(os.path.join( 'target/build-analysis', diff --git a/test/integration/020_ephemeral_test/test_ephemeral.py b/test/integration/020_ephemeral_test/test_ephemeral.py index 4b56543bb45..f2344b39046 100644 --- a/test/integration/020_ephemeral_test/test_ephemeral.py +++ b/test/integration/020_ephemeral_test/test_ephemeral.py @@ -21,7 +21,8 @@ def test__postgres(self): self.use_default_project() self.run_sql_file("test/integration/020_ephemeral_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 2) self.assertTablesEqual("seed", "dependent") self.assertTablesEqual("seed", "double_dependent") @@ -32,7 +33,8 @@ def test__snowflake(self): self.use_default_project() self.run_sql_file("test/integration/020_ephemeral_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 2) self.assertTablesEqual("SEED", "dependent") self.assertTablesEqual("SEED", "double_dependent") diff --git a/test/integration/021_concurrency_test/test_concurrency.py b/test/integration/021_concurrency_test/test_concurrency.py index 6a5449178d1..3b1f49d343e 100644 --- a/test/integration/021_concurrency_test/test_concurrency.py +++ b/test/integration/021_concurrency_test/test_concurrency.py @@ -21,7 +21,8 @@ def test__postgres__concurrency(self): self.use_default_project() self.run_sql_file("test/integration/021_concurrency_test/seed.sql") - self.run_dbt(expect_pass=False) + results = self.run_dbt(expect_pass=False) + self.assertEqual(len(results), 7) self.assertTablesEqual("seed", "view_model") self.assertTablesEqual("seed", "dep") @@ -32,7 +33,8 @@ def test__postgres__concurrency(self): self.run_sql_file("test/integration/021_concurrency_test/update.sql") - self.run_dbt(expect_pass=False) + results = self.run_dbt(expect_pass=False) + self.assertEqual(len(results), 7) self.assertTablesEqual("seed", "view_model") self.assertTablesEqual("seed", "dep") @@ -47,7 +49,8 @@ def test__snowflake__concurrency(self): self.use_default_project() self.run_sql_file("test/integration/021_concurrency_test/seed.sql") - self.run_dbt(expect_pass=False) + results = self.run_dbt(expect_pass=False) + self.assertEqual(len(results), 7) self.assertTablesEqual("SEED", "view_model") self.assertTablesEqual("SEED", "dep") @@ -56,7 +59,8 @@ def test__snowflake__concurrency(self): self.run_sql_file("test/integration/021_concurrency_test/update.sql") - self.run_dbt(expect_pass=False) + results = self.run_dbt(expect_pass=False) + self.assertEqual(len(results), 7) self.assertTablesEqual("SEED", "view_model") self.assertTablesEqual("SEED", "dep") diff --git a/test/integration/022_bigquery_test/test_bigquery_adapter_functions.py b/test/integration/022_bigquery_test/test_bigquery_adapter_functions.py index 95bde58d566..359ef5b204c 100644 --- a/test/integration/022_bigquery_test/test_bigquery_adapter_functions.py +++ b/test/integration/022_bigquery_test/test_bigquery_adapter_functions.py @@ -20,7 +20,8 @@ def profile_config(self): def test__bigquery_adapter_functions(self): self.use_profile('bigquery') self.use_default_project() - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 3) test_results = self.run_dbt(['test']) diff --git a/test/integration/022_bigquery_test/test_bigquery_date_partitioning.py b/test/integration/022_bigquery_test/test_bigquery_date_partitioning.py index c4c946fca6e..b7fde63992c 100644 --- a/test/integration/022_bigquery_test/test_bigquery_date_partitioning.py +++ b/test/integration/022_bigquery_test/test_bigquery_date_partitioning.py @@ -20,7 +20,8 @@ def profile_config(self): def test__bigquery_date_partitioning(self): self.use_profile('bigquery') self.use_default_project() - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 6) test_results = self.run_dbt(['test']) diff --git a/test/integration/022_bigquery_test/test_simple_bigquery_view.py b/test/integration/022_bigquery_test/test_simple_bigquery_view.py index 81376f860e2..99a3873bbd0 100644 --- a/test/integration/022_bigquery_test/test_simple_bigquery_view.py +++ b/test/integration/022_bigquery_test/test_simple_bigquery_view.py @@ -30,7 +30,8 @@ def test__bigquery_simple_run(self): # make sure seed works twice. Full-refresh is a no-op self.run_dbt(['seed']) self.run_dbt(['seed', '--full-refresh']) - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 2) # The 'dupe' model should fail, but all others should pass test_results = self.run_dbt(['test'], expect_pass=False) diff --git a/test/integration/023_exit_codes_test/test_exit_codes.py b/test/integration/023_exit_codes_test/test_exit_codes.py index 3831c3298a8..5aa96cc52c1 100644 --- a/test/integration/023_exit_codes_test/test_exit_codes.py +++ b/test/integration/023_exit_codes_test/test_exit_codes.py @@ -37,7 +37,8 @@ def project_config(self): def test_exit_code_run_succeed(self): self.use_profile('postgres') self.use_default_project() - _, success = self.run_dbt_and_check(['run', '--model', 'good']) + results, success = self.run_dbt_and_check(['run', '--model', 'good']) + self.assertEqual(len(results), 1) self.assertTrue(success) self.assertTableDoesExist('good') @@ -45,7 +46,8 @@ def test_exit_code_run_succeed(self): def test__exit_code_run_fail(self): self.use_profile('postgres') self.use_default_project() - _, success = self.run_dbt_and_check(['run', '--model', 'bad']) + results, success = self.run_dbt_and_check(['run', '--model', 'bad']) + self.assertEqual(len(results), 1) self.assertFalse(success) self.assertTableDoesNotExist('bad') @@ -53,25 +55,30 @@ def test__exit_code_run_fail(self): def test___schema_test_pass(self): self.use_profile('postgres') self.use_default_project() - _, success = self.run_dbt_and_check(['run', '--model', 'good']) + results, success = self.run_dbt_and_check(['run', '--model', 'good']) + self.assertEqual(len(results), 1) self.assertTrue(success) - _, success = self.run_dbt_and_check(['test', '--model', 'good']) + results, success = self.run_dbt_and_check(['test', '--model', 'good']) + self.assertEqual(len(results), 1) self.assertTrue(success) @attr(type='postgres') def test___schema_test_fail(self): self.use_profile('postgres') self.use_default_project() - _, success = self.run_dbt_and_check(['run', '--model', 'dupe']) + results, success = self.run_dbt_and_check(['run', '--model', 'dupe']) + self.assertEqual(len(results), 1) self.assertTrue(success) - _, success = self.run_dbt_and_check(['test', '--model', 'dupe']) + results, success = self.run_dbt_and_check(['test', '--model', 'dupe']) + self.assertEqual(len(results), 1) self.assertFalse(success) @attr(type='postgres') def test___compile(self): self.use_profile('postgres') self.use_default_project() - _, success = self.run_dbt_and_check(['compile']) + results, success = self.run_dbt_and_check(['compile']) + self.assertEqual(len(results), 7) self.assertTrue(success) @attr(type='postgres') @@ -80,7 +87,8 @@ def test___archive_pass(self): self.use_default_project() self.run_dbt_and_check(['run', '--model', 'good']) - _, success = self.run_dbt_and_check(['archive']) + results, success = self.run_dbt_and_check(['archive']) + self.assertEqual(len(results), 1) self.assertTableDoesExist('good_archive') self.assertTrue(success) @@ -118,10 +126,12 @@ def test___archive_fail(self): self.use_profile('postgres') self.use_default_project() - _, success = self.run_dbt_and_check(['run', '--model', 'good']) + results, success = self.run_dbt_and_check(['run', '--model', 'good']) self.assertTrue(success) + self.assertEqual(len(results), 1) - _, success = self.run_dbt_and_check(['archive']) + results, success = self.run_dbt_and_check(['archive']) + self.assertEqual(len(results), 1) self.assertTableDoesNotExist('good_archive') self.assertFalse(success) @@ -191,7 +201,8 @@ def project_config(self): @attr(type='postgres') def test_seed(self): - _, success = self.run_dbt_and_check(['seed']) + results, success = self.run_dbt_and_check(['seed']) + self.assertEqual(len(results), 1) self.assertTrue(success) class TestExitCodesSeedFail(DBTIntegrationTest): diff --git a/test/integration/024_custom_schema_test/test_custom_schema.py b/test/integration/024_custom_schema_test/test_custom_schema.py index c51dc476943..4a64d7e419f 100644 --- a/test/integration/024_custom_schema_test/test_custom_schema.py +++ b/test/integration/024_custom_schema_test/test_custom_schema.py @@ -17,7 +17,8 @@ def test__postgres__custom_schema_no_prefix(self): self.use_default_project() self.run_sql_file("test/integration/024_custom_schema_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 3) schema = self.unique_schema() v2_schema = "{}_custom".format(schema) @@ -71,7 +72,8 @@ def test__postgres__custom_schema_with_prefix(self): self.use_default_project() self.run_sql_file("test/integration/024_custom_schema_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 3) schema = self.unique_schema() v1_schema = "{}_dbt_test".format(schema) @@ -127,7 +129,8 @@ def test__postgres__custom_schema_from_macro(self): self.use_default_project() self.run_sql_file("test/integration/024_custom_schema_test/seed.sql") - self.run_dbt() + results = self.run_dbt() + self.assertEqual(len(results), 3) schema = self.unique_schema() v1_schema = "dbt_test_{}_macro".format(schema) diff --git a/test/integration/025_duplicate_model_test/test_duplicate_model.py b/test/integration/025_duplicate_model_test/test_duplicate_model.py index 77a576537e0..23cd526b215 100644 --- a/test/integration/025_duplicate_model_test/test_duplicate_model.py +++ b/test/integration/025_duplicate_model_test/test_duplicate_model.py @@ -83,10 +83,11 @@ def profile_config(self): @attr(type="postgres") def test_duplicate_model_disabled(self): try: - self.run_dbt(["run"]) + results = self.run_dbt(["run"]) except CompilationException: self.fail( "Compilation Exception raised on disabled model") + self.assertEqual(len(results), 1) query = "select value from {schema}.model" \ .format(schema=self.unique_schema()) result = self.run_sql(query, fetch="one")[0] diff --git a/test/integration/025_timezones_test/test_timezones.py b/test/integration/025_timezones_test/test_timezones.py index af995eaef31..3391d4fe1bf 100644 --- a/test/integration/025_timezones_test/test_timezones.py +++ b/test/integration/025_timezones_test/test_timezones.py @@ -48,7 +48,8 @@ def query(self): @freeze_time("2017-01-01 03:00:00", tz_offset=0) @attr(type='postgres') def test_run_started_at(self): - self.run_dbt(['run']) + results = self.run_dbt(['run']) + self.assertEqual(len(results), 1) result = self.run_sql(self.query, fetch='all')[0] est, utc = result self.assertEqual(utc, '2017-01-01 03:00:00+00:00') diff --git a/test/integration/026_aliases_test/test_aliases.py b/test/integration/026_aliases_test/test_aliases.py index bb7dce6ac7e..39e301e40e6 100644 --- a/test/integration/026_aliases_test/test_aliases.py +++ b/test/integration/026_aliases_test/test_aliases.py @@ -30,19 +30,22 @@ def project_config(self): @attr(type='postgres') def test__alias_model_name(self): self.use_profile('postgres') - self.run_dbt(['run']) + results = self.run_dbt(['run']) + self.assertEqual(len(results), 4) self.run_dbt(['test']) @attr(type='bigquery') def test__alias_model_name_bigquery(self): self.use_profile('bigquery') - self.run_dbt(['run']) + results = self.run_dbt(['run']) + self.assertEqual(len(results), 4) self.run_dbt(['test']) @attr(type='snowflake') def test__alias_model_name_snowflake(self): self.use_profile('snowflake') - self.run_dbt(['run']) + results = self.run_dbt(['run']) + self.assertEqual(len(results), 4) self.run_dbt(['test']) class TestAliasErrors(DBTIntegrationTest): @@ -83,7 +86,8 @@ def project_config(self): @attr(type='postgres') def test__same_alias_succeeds_in_different_schemas(self): - self.run_dbt(['run']) + results = self.run_dbt(['run']) + self.assertEqual(len(results), 3) res = self.run_dbt(['test']) # Make extra sure the tests ran diff --git a/test/integration/028_cli_vars/test_cli_vars.py b/test/integration/028_cli_vars/test_cli_vars.py index 166dcb7f4c5..1184c7a9788 100644 --- a/test/integration/028_cli_vars/test_cli_vars.py +++ b/test/integration/028_cli_vars/test_cli_vars.py @@ -24,8 +24,10 @@ def test__cli_vars_longform(self): "value": "jkl" } } - self.run_dbt(["run", "--vars", yaml.dump(cli_vars)]) - self.run_dbt(["test", "--vars", yaml.dump(cli_vars)]) + results = self.run_dbt(["run", "--vars", yaml.dump(cli_vars)]) + self.assertEqual(len(results), 1) + results = self.run_dbt(["test", "--vars", yaml.dump(cli_vars)]) + self.assertEqual(len(results), 3) class TestCLIVarsSimple(DBTIntegrationTest): @@ -42,13 +44,17 @@ def test__cli_vars_shorthand(self): self.use_profile('postgres') self.use_default_project() - self.run_dbt(["run", "--vars", "simple: abc"]) - self.run_dbt(["test", "--vars", "simple: abc"]) + results = self.run_dbt(["run", "--vars", "simple: abc"]) + self.assertEqual(len(results), 1) + results = self.run_dbt(["test", "--vars", "simple: abc"]) + self.assertEqual(len(results), 1) @attr(type='postgres') def test__cli_vars_longer(self): self.use_profile('postgres') self.use_default_project() - self.run_dbt(["run", "--vars", "{simple: abc, unused: def}"]) - self.run_dbt(["test", "--vars", "{simple: abc, unused: def}"]) + results = self.run_dbt(["run", "--vars", "{simple: abc, unused: def}"]) + self.assertEqual(len(results), 1) + results = self.run_dbt(["test", "--vars", "{simple: abc, unused: def}"]) + self.assertEqual(len(results), 1) diff --git a/test/integration/030_statement_test/test_statements.py b/test/integration/030_statement_test/test_statements.py index 76946bad003..ac131e41dd1 100644 --- a/test/integration/030_statement_test/test_statements.py +++ b/test/integration/030_statement_test/test_statements.py @@ -21,8 +21,10 @@ def test_postgres_statements(self): self.use_profile("postgres") self.use_default_project({"data-paths": [self.dir("seed")]}) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 2) + results = self.run_dbt() + self.assertEqual(len(results), 1) self.assertTablesEqual("statement_actual","statement_expected") @@ -31,8 +33,10 @@ def test_snowflake_statements(self): self.use_profile("postgres") self.use_default_project({"data-paths": [self.dir("seed")]}) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 2) + results = self.run_dbt() + self.assertEqual(len(results), 1) self.assertTablesEqual("statement_actual","statement_expected") @@ -41,8 +45,10 @@ def test_bigquery_statements(self): self.use_profile("postgres") self.use_default_project({"data-paths": [self.dir("seed")]}) - self.run_dbt(["seed"]) - self.run_dbt() + results = self.run_dbt(["seed"]) + self.assertEqual(len(results), 2) + results = self.run_dbt() + self.assertEqual(len(results), 1) self.assertTablesEqual("statement_actual","statement_expected") diff --git a/test/integration/031_thread_count_test/test_thread_count.py b/test/integration/031_thread_count_test/test_thread_count.py index 41a0d7ffde6..208acadd686 100644 --- a/test/integration/031_thread_count_test/test_thread_count.py +++ b/test/integration/031_thread_count_test/test_thread_count.py @@ -6,7 +6,7 @@ import os -class TestDataTests(DBTIntegrationTest): +class TestThreadCount(DBTIntegrationTest): @property def project_config(self): @@ -30,4 +30,5 @@ def models(self): def test_postgres_threading_8x(self): self.use_profile('postgres') - self.run_dbt(args=['run', '--threads', '16']) + results = self.run_dbt(args=['run', '--threads', '16']) + self.assertTrue(len(results), 20) diff --git a/test/integration/032_concurrent_transaction_test/test_concurrent_transaction.py b/test/integration/032_concurrent_transaction_test/test_concurrent_transaction.py index 428d3e42421..43a728486c8 100644 --- a/test/integration/032_concurrent_transaction_test/test_concurrent_transaction.py +++ b/test/integration/032_concurrent_transaction_test/test_concurrent_transaction.py @@ -61,7 +61,8 @@ def run_test(self): self.use_profile("redshift") # First run the project to make sure the models exist - self.run_dbt(args=['run']) + results = self.run_dbt(args=['run']) + self.assertEqual(len(results), 2) # Execute long-running queries in threads t1 = self.async_select('view_model', 10) @@ -69,6 +70,7 @@ def run_test(self): # While the queries are executing, re-run the project res = self.run_dbt(args=['run', '--threads', '8']) + self.assertEqual(len(res), 2) # Finally, wait for these threads to finish t1.join()