text: from test.integration.base import DBTIntegrationTest, use_profile
  
  class TestSnowflakeLateBindingViewDependency(DBTIntegrationTest):
  
      @property
      def schema(self):
          return "snowflake_view_dependency_test_036"
  
      @property
      def models(self):
          return "models"
  
      @property
      def project_config(self):
          return {
              "data-paths": ["data"],
              "quoting": {
                  "schema": False,
                  "identifier": False
              }
          }
  
      """
      Snowflake views are not bound to the relations they select from. A Snowflake view
      can have entirely invalid SQL if, for example, the table it selects from is dropped
      and recreated with a different schema. In these scenarios, Snowflake will raise an error if:
      1) The view is queried
      2) The view is altered
  
      dbt's logic should avoid running these types of queries against views in situations
      where they _may_ have invalid definitions. These tests assert that views are handled
      correctly in various different scenarios
      """
  
      @use_profile('snowflake')
      def test__snowflake__changed_table_schema_for_downstream_view(self):
          results = self.run_dbt(["seed"])
          self.assertEqual(len(results),  1)
  
          results = self.run_dbt(["run"])
          self.assertEqual(len(results),  2)
          self.assertManyTablesEqual(["PEOPLE", "BASE_TABLE", "DEPENDENT_MODEL"])
  
          # Change the schema of base_table, assert that dependent_model doesn't fail
          results = self.run_dbt(["run", "--vars", "{add_table_field: true, dependent_type: view}"])
          self.assertEqual(len(results),  2)
          self.assertManyTablesEqual(["BASE_TABLE", "DEPENDENT_MODEL"])
  
      """
      This test is similar to the one above, except the downstream model starts as a view, and
      then is changed to be a table. This checks that the table materialization does not
      errantly rename a view that might have an invalid definition, which would cause an error
      """
      @use_profile('snowflake')
      def test__snowflake__changed_table_schema_for_downstream_view_changed_to_table(self):
          results = self.run_dbt(["seed"])
          self.assertEqual(len(results),  1)
  
          results = self.run_dbt(["run"])
          self.assertEqual(len(results),  2)
          self.assertManyTablesEqual(["PEOPLE", "BASE_TABLE", "DEPENDENT_MODEL"])
  
          expected_types = {
              'base_table': 'table',
              'dependent_model': 'view'
          }
  
          # ensure that the model actually was materialized as a table
          for result in results:
              node_name = result.node.name
              self.assertEqual(result.node.config.materialized, expected_types[node_name])
  
          results = self.run_dbt(["run", "--vars", "{add_table_field: true, dependent_type: table}"])
          self.assertEqual(len(results),  2)
          self.assertManyTablesEqual(["BASE_TABLE", "DEPENDENT_MODEL"])
  
          expected_types = {
              'base_table': 'table',
              'dependent_model': 'table'
          }
  
          # ensure that the model actually was materialized as a table
          for result in results:
              node_name = result.node.name
              self.assertEqual(result.node.config.materialized, expected_types[node_name])
  
      @use_profile('presto')
      def test__presto__changed_table_schema_for_downstream_view(self):
          results = self.run_dbt(["seed"])
          self.assertEqual(len(results),  1)
  
          results = self.run_dbt(["run"])
          self.assertEqual(len(results),  2)
          self.assertManyTablesEqual(["people", "base_table", "dependent_model"])
  
          # Change the schema of base_table, assert that dependent_model doesn't fail
          results = self.run_dbt(["run", "--vars", "{add_table_field: true, dependent_type: view}"])
          self.assertEqual(len(results),  2)
          self.assertManyTablesEqual(["base_table", "dependent_model"])
  
      @use_profile('presto')
      def test__presto__changed_table_schema_for_downstream_view_changed_to_table(self):
          results = self.run_dbt(["seed"])
          self.assertEqual(len(results),  1)
  
          results = self.run_dbt(["run"])
          self.assertEqual(len(results),  2)
          self.assertManyTablesEqual(["people", "base_table", "dependent_model"])
  
          expected_types = {
              'base_table': 'table',
              'dependent_model': 'view'
          }
  
          # ensure that the model actually was materialized as a table
          for result in results:
              node_name = result.node.name
              self.assertEqual(result.node.config.materialized, expected_types[node_name])
  
          results = self.run_dbt(["run", "--vars", "{add_table_field: true, dependent_type: table}"])
          self.assertEqual(len(results),  2)
          self.assertManyTablesEqual(["base_table", "dependent_model"])
  
          expected_types = {
              'base_table': 'table',
              'dependent_model': 'table'
          }
  
          # ensure that the model actually was materialized as a table
          for result in results:
              node_name = result.node.name
              self.assertEqual(result.node.config.materialized, expected_types[node_name])
  