class MacroParserTest(BaseParserTest):
def setUp(self):
super().setUp()
self.parser = MacroParser(
results=ParseResult.rpc(),
project=self.snowplow_project_config,
)
def file_block_for(self, data, filename):
return super().file_block_for(data, filename, 'macros')
def test_single_block(self):
raw_sql = '{% macro foo(a, b) %}a ~ b{% endmacro %}'
block = self.file_block_for(raw_sql, 'macro.sql')
self.parser.parse_file(block)
self.assert_has_results_length(self.parser.results, macros=1)
macro = list(self.parser.results.macros.values())[0]
expected = ParsedMacro(
name='foo',
resource_type=NodeType.Macro,
unique_id='macro.snowplow.foo',
package_name='snowplow',
original_file_path=normalize('macros/macro.sql'),
root_path=get_abs_os_path('./dbt_modules/snowplow'),
path=normalize('macros/macro.sql'),
raw_sql=raw_sql
)
self.assertEqual(macro, expected)
path = get_abs_os_path('./dbt_modules/snowplow/macros/macro.sql')
self.assertIn(path, self.parser.results.files)
self.assertEqual(self.parser.results.files[path].macros, ['macro.snowplow.foo'])
def _load_macro_nodes(self, resource_type):
parser = MacroParser(self.root_project, self.all_projects)
for project_name, project in self.all_projects.items():
self.macros.update(
parser.load_and_parse(
package_name=project_name,
root_dir=project.project_root,
relative_dirs=project.macro_paths,
resource_type=resource_type,
))
# make a manifest with just the macros to get the context
self.macro_manifest = Manifest(macros=self.macros,
nodes={},
docs={},
generated_at=timestring(),
disabled=[])
def _load_macros(self, internal_manifest=None):
# skip any projects in the internal manifest
all_projects = self.all_projects.copy()
if internal_manifest is not None:
for name in internal_project_names():
all_projects.pop(name, None)
self.macros.update(internal_manifest.macros)
# give the macroparser all projects but then only load what we haven't
# loaded already
parser = MacroParser(self.root_project, self.all_projects)
for project_name, project in all_projects.items():
self.macros.update(parser.load_and_parse(
package_name=project_name,
root_dir=project.project_root,
relative_dirs=project.macro_paths,
resource_type=NodeType.Macro,
))
def _load_macros(self, internal_manifest=None):
# skip any projects in the internal manifest
all_projects = self.all_projects.copy()
if internal_manifest is not None:
for name in internal_project_names():
all_projects.pop(name, None)
self.macros.update(internal_manifest.macros)
# give the macroparser all projects but then only load what we haven't
# loaded already
parser = MacroParser(self.root_project, self.all_projects)
for project_name, project in all_projects.items():
self.macros.update(
parser.load_and_parse(
package_name=project_name,
root_dir=project.project_root,
relative_dirs=project.macro_paths,
resource_type=NodeType.Macro,
))
def _load_macro_nodes(self, resource_type):
for project_name, project in self.all_projects.items():
self.macros.update(
MacroParser.load_and_parse(
package_name=project_name,
root_project=self.root_project,
all_projects=self.all_projects,
root_dir=project.project_root,
relative_dirs=project.macro_paths,
resource_type=resource_type,
))
def setUp(self):
super().setUp()
self.parser = MacroParser(
results=ParseResult.rpc(),
project=self.snowplow_project_config,
)
def setUp(self):
super().setUp()
self.parser = MacroParser(project=self.snowplow_project_config,
manifest=Manifest({}, {}, {}, {}, {}, {}, {},
{}))
class MacroParserTest(BaseParserTest):
def setUp(self):
super().setUp()
self.parser = MacroParser(project=self.snowplow_project_config,
manifest=Manifest({}, {}, {}, {}, {}, {}, {},
{}))
def file_block_for(self, data, filename):
return super().file_block_for(data, filename, 'macros')
def test_single_block(self):
raw_sql = '{% macro foo(a, b) %}a ~ b{% endmacro %}'
block = self.file_block_for(raw_sql, 'macro.sql')
self.parser.parse_file(block)
self.assertEqual(len(self.parser.manifest.macros), 1)
macro = list(self.parser.manifest.macros.values())[0]
expected = ParsedMacro(
name='foo',
resource_type=NodeType.Macro,
unique_id='macro.snowplow.foo',
package_name='snowplow',
original_file_path=normalize('macros/macro.sql'),
root_path=get_abs_os_path('./dbt_modules/snowplow'),
path=normalize('macros/macro.sql'),
macro_sql=raw_sql,
)
self.assertEqual(macro, expected)
path = get_abs_os_path('./dbt_modules/snowplow/macros/macro.sql')
self.assertIn(path, self.parser.manifest.files)
self.assertEqual(self.parser.manifest.files[path].macros,
['macro.snowplow.foo'])
def test_multiple_blocks(self):
raw_sql = '{% macro foo(a, b) %}a ~ b{% endmacro %}\n{% macro bar(c, d) %}c + d{% endmacro %}'
block = self.file_block_for(raw_sql, 'macro.sql')
self.parser.parse_file(block)
self.assertEqual(len(self.parser.manifest.macros), 2)
macros = sorted(self.parser.manifest.macros.values(),
key=lambda m: m.name)
expected_bar = ParsedMacro(
name='bar',
resource_type=NodeType.Macro,
unique_id='macro.snowplow.bar',
package_name='snowplow',
original_file_path=normalize('macros/macro.sql'),
root_path=get_abs_os_path('./dbt_modules/snowplow'),
path=normalize('macros/macro.sql'),
macro_sql='{% macro bar(c, d) %}c + d{% endmacro %}',
)
expected_foo = ParsedMacro(
name='foo',
resource_type=NodeType.Macro,
unique_id='macro.snowplow.foo',
package_name='snowplow',
original_file_path=normalize('macros/macro.sql'),
root_path=get_abs_os_path('./dbt_modules/snowplow'),
path=normalize('macros/macro.sql'),
macro_sql='{% macro foo(a, b) %}a ~ b{% endmacro %}',
)
self.assertEqual(macros, [expected_bar, expected_foo])
path = get_abs_os_path('./dbt_modules/snowplow/macros/macro.sql')
self.assertIn(path, self.parser.manifest.files)
self.assertEqual(
sorted(self.parser.manifest.files[path].macros),
['macro.snowplow.bar', 'macro.snowplow.foo'],
)