def test_basic(self):
raw_sql = 'select 1 as id'
block = self.file_block_for(raw_sql, 'nested/analysis_1.sql')
self.parser.parse_file(block)
self.assert_has_results_length(self.parser.results, nodes=1)
node = list(self.parser.results.nodes.values())[0]
expected = ParsedAnalysisNode(
alias='analysis_1',
name='analysis_1',
database='test',
schema='analytics',
resource_type=NodeType.Analysis,
unique_id='analysis.snowplow.analysis_1',
fqn=['snowplow', 'analysis', 'nested', 'analysis_1'],
package_name='snowplow',
original_file_path=normalize('analyses/nested/analysis_1.sql'),
root_path=get_abs_os_path('./dbt_modules/snowplow'),
depends_on=DependsOn(),
config=NodeConfig(),
path=normalize('analysis/nested/analysis_1.sql'),
raw_sql=raw_sql,
)
self.assertEqual(node, expected)
path = get_abs_os_path(
'./dbt_modules/snowplow/analyses/nested/analysis_1.sql')
self.assertIn(path, self.parser.results.files)
self.assertEqual(self.parser.results.files[path].nodes,
['analysis.snowplow.analysis_1'])
def test_basic(self):
raw_sql = '{{ config(materialized="table") }}select 1 as id'
block = self.file_block_for(raw_sql, 'nested/model_1.sql')
self.parser.parse_file(block)
self.assert_has_results_length(self.parser.results, nodes=1)
node = list(self.parser.results.nodes.values())[0]
expected = ParsedModelNode(
alias='model_1',
name='model_1',
database='test',
schema='analytics',
resource_type=NodeType.Model,
unique_id='model.snowplow.model_1',
fqn=['snowplow', 'nested', 'model_1'],
package_name='snowplow',
original_file_path=normalize('models/nested/model_1.sql'),
root_path=get_abs_os_path('./dbt_modules/snowplow'),
config=NodeConfig(materialized='table'),
path=normalize('nested/model_1.sql'),
raw_sql=raw_sql,
)
self.assertEqual(node, expected)
path = get_abs_os_path(
'./dbt_modules/snowplow/models/nested/model_1.sql')
self.assertIn(path, self.parser.results.files)
self.assertEqual(self.parser.results.files[path].nodes,
['model.snowplow.model_1'])
def patch_invalid(self):
initial = self.ContractType(
package_name='test',
root_path='/root/',
path='/root/x/path.sql',
original_file_path='/root/path.sql',
raw_sql='select * from wherever',
name='foo',
resource_type=NodeType.Model,
unique_id='model.test.foo',
fqn=['test', 'models', 'foo'],
refs=[],
sources=[],
depends_on=DependsOn(),
description='',
database='test_db',
schema='test_schema',
alias='bar',
tags=[],
config=NodeConfig(),
)
# invalid patch: description can't be None
patch = ParsedNodePatch(
name='foo',
yaml_key='models',
package_name='test',
description=None,
original_file_path='/path/to/schema.yml',
columns={},
docs=Docs(),
)
with self.assertRaises(ValidationError):
initial.patch(patch)
def test_ok(self):
node_dict = self._hook_ok()
node = self.ContractType(
package_name='test',
root_path='/root/',
path='/root/x/path.sql',
original_file_path='/root/path.sql',
raw_sql='select * from wherever',
name='foo',
resource_type=NodeType.Operation,
unique_id='model.test.foo',
fqn=['test', 'models', 'foo'],
refs=[],
sources=[],
depends_on=DependsOn(),
description='',
database='test_db',
schema='test_schema',
alias='bar',
tags=[],
config=NodeConfig(),
index=10,
)
self.assert_symmetric(node, node_dict)
self.assertFalse(node.empty)
self.assertFalse(node.is_refable)
self.assertEqual(node.get_materialization(), 'view')
node.index = None
minimum = {
'name': 'foo',
'root_path': '/root/',
'resource_type': str(NodeType.Operation),
'path': '/root/x/path.sql',
'original_file_path': '/root/path.sql',
'package_name': 'test',
'raw_sql': 'select * from wherever',
'unique_id': 'model.test.foo',
'fqn': ['test', 'models', 'foo'],
'database': 'test_db',
'schema': 'test_schema',
'alias': 'bar',
}
self.assert_from_dict(node, minimum)
pickle.loads(pickle.dumps(node))
def test_complex(self):
node_dict = {
'name': 'foo',
'root_path': '/root/',
'resource_type': str(NodeType.Operation),
'path': '/root/x/path.sql',
'original_file_path': '/root/path.sql',
'package_name': 'test',
'raw_sql': 'select * from {{ ref("bar") }}',
'unique_id': 'model.test.foo',
'fqn': ['test', 'models', 'foo'],
'refs': [],
'sources': [],
'depends_on': {
'macros': [],
'nodes': ['model.test.bar']
},
'database': 'test_db',
'description': 'My parsed node',
'schema': 'test_schema',
'alias': 'bar',
'tags': ['tag'],
'meta': {},
'config': {
'column_types': {
'a': 'text'
},
'enabled': True,
'materialized': 'table',
'persist_docs': {},
'post-hook': [],
'pre-hook': [],
'quoting': {},
'tags': [],
'vars': {},
},
'docs': {
'show': True
},
'columns': {
'a': {
'name': 'a',
'description': 'a text field',
'meta': {},
'tags': [],
},
},
'index': 13,
}
node = self.ContractType(
package_name='test',
root_path='/root/',
path='/root/x/path.sql',
original_file_path='/root/path.sql',
raw_sql='select * from {{ ref("bar") }}',
name='foo',
resource_type=NodeType.Operation,
unique_id='model.test.foo',
fqn=['test', 'models', 'foo'],
refs=[],
sources=[],
depends_on=DependsOn(nodes=['model.test.bar']),
description='My parsed node',
database='test_db',
schema='test_schema',
alias='bar',
tags=['tag'],
meta={},
config=NodeConfig(column_types={'a': 'text'},
materialized='table',
post_hook=[]),
columns={'a': ColumnInfo('a', 'a text field', {})},
index=13,
)
self.assert_symmetric(node, node_dict)
self.assertFalse(node.empty)
self.assertFalse(node.is_refable)
self.assertEqual(node.get_materialization(), 'table')
def test_patch_ok(self):
initial = self.ContractType(
package_name='test',
root_path='/root/',
path='/root/x/path.sql',
original_file_path='/root/path.sql',
raw_sql='select * from wherever',
name='foo',
resource_type=NodeType.Model,
unique_id='model.test.foo',
fqn=['test', 'models', 'foo'],
refs=[],
sources=[],
depends_on=DependsOn(),
description='',
database='test_db',
schema='test_schema',
alias='bar',
tags=[],
meta={},
config=NodeConfig(),
)
patch = ParsedNodePatch(
name='foo',
yaml_key='models',
package_name='test',
description='The foo model',
original_file_path='/path/to/schema.yml',
columns={
'a': ColumnInfo(name='a', description='a text field', meta={})
},
docs=Docs(),
meta={},
)
initial.patch(patch)
expected_dict = {
'name': 'foo',
'root_path': '/root/',
'resource_type': str(NodeType.Model),
'path': '/root/x/path.sql',
'original_file_path': '/root/path.sql',
'package_name': 'test',
'raw_sql': 'select * from wherever',
'unique_id': 'model.test.foo',
'fqn': ['test', 'models', 'foo'],
'refs': [],
'sources': [],
'depends_on': {
'macros': [],
'nodes': []
},
'database': 'test_db',
'description': 'The foo model',
'schema': 'test_schema',
'alias': 'bar',
'tags': [],
'meta': {},
'config': {
'column_types': {},
'enabled': True,
'materialized': 'view',
'persist_docs': {},
'post-hook': [],
'pre-hook': [],
'quoting': {},
'tags': [],
'vars': {},
},
'patch_path': '/path/to/schema.yml',
'columns': {
'a': {
'name': 'a',
'description': 'a text field',
'meta': {},
'tags': [],
},
},
'docs': {
'show': True
},
}
expected = self.ContractType(
package_name='test',
root_path='/root/',
path='/root/x/path.sql',
original_file_path='/root/path.sql',
raw_sql='select * from wherever',
name='foo',
resource_type=NodeType.Model,
unique_id='model.test.foo',
fqn=['test', 'models', 'foo'],
refs=[],
sources=[],
depends_on=DependsOn(),
description='The foo model',
database='test_db',
schema='test_schema',
alias='bar',
tags=[],
meta={},
config=NodeConfig(),
patch_path='/path/to/schema.yml',
columns={
'a': ColumnInfo(name='a', description='a text field', meta={})
},
docs=Docs(),
)
self.assert_symmetric(expected, expected_dict) # sanity check
self.assertEqual(initial, expected)
self.assert_symmetric(initial, expected_dict)