mirror of
https://github.com/IfcOpenShell/IfcOpenShell.git
synced 2026-08-14 11:24:19 +00:00
Dion Moult
8023a992da
For now probably just easier to skip tabs. They are just containers and not worth testing. Famous last words :)
1878 lines
72 KiB
Python
1878 lines
72 KiB
Python
# Bonsai - OpenBIM Blender Add-on
|
|
# Copyright (C) 2021 Dion Moult <dion@thinkmoult.com>
|
|
#
|
|
# This file is part of Bonsai.
|
|
#
|
|
# Bonsai is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Bonsai is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with Bonsai. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import pprint
|
|
import shutil
|
|
import traceback
|
|
import types
|
|
import webbrowser
|
|
from collections.abc import Generator
|
|
from inspect import signature
|
|
from math import radians
|
|
from pathlib import Path
|
|
from typing import Any, Union
|
|
|
|
import bpy
|
|
import ifcopenshell
|
|
import ifcopenshell.util.element
|
|
import ifcopenshell.util.representation
|
|
import numpy as np
|
|
import pytest
|
|
from mathutils import Vector
|
|
from pytest_bdd import given, parsers, scenarios, then, when
|
|
|
|
import bonsai.bim.handler
|
|
import bonsai.tool as tool
|
|
import test.bim.stub
|
|
from bonsai.bim.ifc import IfcStore
|
|
from bonsai.bim.module.model.data import AuthoringData
|
|
from bonsai.tool.brick import BrickStore
|
|
|
|
scenarios("feature")
|
|
|
|
variables = {
|
|
"cwd": Path.cwd().as_posix(),
|
|
"ifc_dir": os.path.join(Path.cwd().as_posix(), "test", "files", "temp"),
|
|
"ifc": "tool.Ifc.get()",
|
|
"pset_ifc": "IfcStore.pset_template_file",
|
|
"classification_ifc": "IfcStore.classification_file",
|
|
"temp_project_path": tool.Project.TEMP_PROJECT_PATH.as_posix(),
|
|
}
|
|
|
|
# Monkey-patch webbrowser opening since we want to test headlessly
|
|
webbrowser.open = lambda x: True
|
|
|
|
|
|
tool.Bsdd.client = test.bim.stub.bSDDClientStub()
|
|
|
|
PYTEST_BLENDER_NO_BACKGROUND = bool(os.getenv("PYTEST_BLENDER_NO_BACKGROUND"))
|
|
"""Option to run Blender not in background.
|
|
|
|
Can be useful for debugging, but has caveats - can't use ``wm.read_homefile``
|
|
as resets the ``bpy.context`` and some it's members become `None`.
|
|
"""
|
|
|
|
TMP = Path(f"{variables['cwd']}/test/files/temp")
|
|
|
|
EPSET_DRAWING = Path.cwd() / "bonsai/bim/data/pset/EPset_Drawing.ifc"
|
|
EPSET_DRAWING_BYTES = EPSET_DRAWING.read_bytes()
|
|
RELOAD_EPSET_DRAWING = False
|
|
|
|
|
|
class PanelSpy:
|
|
def __init__(self, blender_panel: type[bpy.types.Panel]):
|
|
self.is_spy_dirty = True
|
|
self.blender_panel = blender_panel
|
|
|
|
def refresh_spy(self) -> None:
|
|
if self.is_spy_dirty:
|
|
self.is_spy_dirty = False
|
|
self.spied_attr: Union[str, None] = None
|
|
self.spied_labels: list[str] = []
|
|
self.spied_props: list[dict[str, Any]] = []
|
|
self.spied_operators: list[dict[str, Any]] = []
|
|
self.spied_lists: list[TemplateListSpy] = []
|
|
if hasattr(self.blender_panel, "draw_header"):
|
|
self.blender_panel.draw_header(self, bpy.context)
|
|
self.blender_panel.draw(self, bpy.context)
|
|
|
|
def __getattr__(self, attr: str) -> PanelSpy | Any:
|
|
self.spied_attr = attr
|
|
try:
|
|
annotations = self.blender_panel.__annotations__
|
|
except AttributeError:
|
|
annotations = type(self.blender_panel).__annotations__
|
|
if annotation := annotations.get(attr, None):
|
|
return annotation.keywords.get("default", None) # An operator property
|
|
if attr == "layout":
|
|
return self
|
|
sentinel = object()
|
|
attr_value = getattr(self.blender_panel, attr, sentinel)
|
|
# Don't use `callable`, because we might have `Data` classes as panel attributes.
|
|
if attr_value is not sentinel and not isinstance(attr_value, types.FunctionType):
|
|
return attr_value
|
|
return self
|
|
|
|
def __call__(self, *args: Any, **kwargs: Any) -> PanelSpy | TemplateListSpy | OperatorSpy | Any:
|
|
if self.spied_attr in ("row", "column", "box", "separator", "menu", "operator_menu_enum", "split"):
|
|
return self
|
|
elif self.spied_attr == "template_list":
|
|
listtype_name, list_id, dataptr, propname, active_dataptr, active_propname = args
|
|
spied_data = {
|
|
"listtype_name": listtype_name,
|
|
"list_id": list_id,
|
|
"dataptr": dataptr,
|
|
"propname": propname,
|
|
"active_dataptr": active_dataptr,
|
|
"active_propname": active_propname,
|
|
}
|
|
template_list = TemplateListSpy(getattr(bpy.types, listtype_name), spied_data)
|
|
self.spied_lists.append(template_list)
|
|
return template_list
|
|
elif self.spied_attr == "context_pointer_set":
|
|
return lambda *args, **kwargs: None
|
|
elif self.spied_attr == "label":
|
|
self.spied_labels.append(kwargs["text"])
|
|
return self
|
|
elif self.spied_attr == "prop":
|
|
props, name = args
|
|
props: bpy.types.bpy_struct
|
|
text = kwargs.get("text", props.bl_rna.properties[name].name)
|
|
icon = kwargs.get("icon", None)
|
|
prop_type = props.bl_rna.properties[name].type
|
|
enum_items = []
|
|
if prop_type == "ENUM":
|
|
try:
|
|
annotations = props.__annotations__
|
|
except AttributeError:
|
|
annotations = type(props).__annotations__
|
|
prop_keywords = annotations[name].keywords
|
|
items = prop_keywords.get("items")
|
|
if items is not None:
|
|
if isinstance(items, (list, tuple)):
|
|
enum_items = items
|
|
else:
|
|
# items are retrieved through a callback, not a static list / tuple :
|
|
enum_items = items(props, bpy.context)
|
|
value = getattr(props, name)
|
|
if text:
|
|
self.spied_labels.append(text)
|
|
spied_prop = {
|
|
"props": props,
|
|
"name": name,
|
|
"text": text,
|
|
"icon": icon,
|
|
"value": value,
|
|
"prop_type": prop_type,
|
|
"enum_items": enum_items,
|
|
}
|
|
self.spied_props.append(spied_prop)
|
|
elif self.spied_attr == "operator":
|
|
operator = args[0]
|
|
prefix, op_name = operator.split(".")
|
|
operator = getattr(getattr(bpy.ops, prefix), op_name)
|
|
bl_idname = operator.idname()
|
|
try:
|
|
bl_label = getattr(bpy.types, bl_idname).bl_label
|
|
except: # Doesn't work on built-ins, I don't know what to do
|
|
bl_label = bl_idname
|
|
text = kwargs.get("text", bl_label)
|
|
icon = kwargs.get("icon", None)
|
|
if text:
|
|
self.spied_labels.append(text)
|
|
after = ""
|
|
if self.spied_labels:
|
|
after = self.spied_labels[-1]
|
|
spied_operator = {"operator": operator, "icon": icon, "text": text, "kwargs": {}, "after": after}
|
|
self.spied_operators.append(spied_operator)
|
|
return OperatorSpy(spied_operator)
|
|
elif self.spied_attr == "panel":
|
|
default_closed = kwargs.get("default_closed", False)
|
|
header = self
|
|
panel = None if default_closed else self
|
|
return header, panel
|
|
else:
|
|
return getattr(self.blender_panel, self.spied_attr)(self, *args, **kwargs)
|
|
|
|
|
|
class OperatorSpy:
|
|
def __init__(self, spied_data: dict[str, Any]):
|
|
self.spied_data = spied_data
|
|
|
|
def __setattr__(self, name: str, value: Any) -> None:
|
|
if name == "spied_data":
|
|
# Allow direct setting of spied_data only during initialization
|
|
super().__setattr__(name, value)
|
|
else:
|
|
self.spied_data["kwargs"][name] = value
|
|
|
|
|
|
class TemplateListSpy(PanelSpy):
|
|
items: bpy.types.bpy_prop_collection_idprop[bpy.types.PropertyGroup]
|
|
active_index: int
|
|
active_item: bpy.types.PropertyGroup | None
|
|
blender_panel: type[bpy.types.UIList]
|
|
|
|
def __init__(self, template_list: type[bpy.types.UIList], spied_data: dict[str, Any]):
|
|
self.spied_data = spied_data
|
|
self.items = getattr(self.spied_data["dataptr"], self.spied_data["propname"])
|
|
self.active_index = getattr(self.spied_data["active_dataptr"], self.spied_data["active_propname"])
|
|
self.active_item = tool.Blender.get_active_uilist_element(self.items, self.active_index)
|
|
self.blender_panel = template_list
|
|
|
|
self.rows: list[TemplateListItemSpy] = []
|
|
for item in self.items:
|
|
self.rows.append(TemplateListItemSpy(self, item))
|
|
|
|
def set_active_index(self, index: int) -> None:
|
|
self.active_index = index
|
|
setattr(self.spied_data["active_dataptr"], self.spied_data["active_propname"], self.active_index)
|
|
try:
|
|
self.active_item = self.items[self.active_index]
|
|
except:
|
|
assert False, f"Could not set active index {index}"
|
|
|
|
def __repr__(self) -> str:
|
|
return f"TemplateListSpy({self.spied_data['listtype_name']}, {len(self.items)} items, active_index={self.active_index})"
|
|
|
|
|
|
class TemplateListItemSpy(PanelSpy):
|
|
def __init__(self, parent: TemplateListSpy, item):
|
|
self.blender_panel = blender_panel = parent.blender_panel
|
|
self.spied_attr: Union[str, None] = None
|
|
self.spied_labels: list[str] = []
|
|
self.spied_props: list[dict[str, Any]] = []
|
|
self.spied_operators: list[dict[str, Any]] = []
|
|
if len(signature(blender_panel.draw_item).parameters) == 8:
|
|
blender_panel.draw_item(
|
|
self,
|
|
bpy.context,
|
|
self,
|
|
parent.spied_data["dataptr"],
|
|
item,
|
|
"",
|
|
parent.spied_data["active_dataptr"],
|
|
parent.spied_data["active_propname"],
|
|
)
|
|
else:
|
|
blender_panel.draw_item(
|
|
self,
|
|
bpy.context,
|
|
self,
|
|
parent.spied_data["dataptr"],
|
|
item,
|
|
"",
|
|
parent.spied_data["active_dataptr"],
|
|
parent.spied_data["active_propname"],
|
|
0, # Index?
|
|
None,
|
|
)
|
|
|
|
|
|
ui_name_cache: dict[str, str] = {}
|
|
"""Mapping of UI panel names to their bl_idnames (e.g. `xxx` in `bpy.types.xxx`)."""
|
|
panel_spy: Union[PanelSpy, None] = None
|
|
|
|
|
|
def create_ui_name_cache():
|
|
global ui_name_cache
|
|
if ui_name_cache:
|
|
return
|
|
for bl_idname in dir(bpy.types):
|
|
try:
|
|
panel_type = getattr(bpy.types, bl_idname)
|
|
if panel_type.bl_rna.base.name == "Panel":
|
|
if "_tab_" in panel_type.bl_idname:
|
|
continue # Tab panels are just groups and not relevant in testing
|
|
ui_name_cache[panel_type.bl_label] = panel_type.bl_idname
|
|
elif panel_type.bl_rna.base.name == "Operator":
|
|
ui_name_cache[panel_type.bl_label] = bl_idname
|
|
elif panel_type.bl_rna.base.name == "Menu":
|
|
if panel_type.bl_label == "Add" and bl_idname != "VIEW3D_MT_add":
|
|
continue # Non-unique, but "VIEW3D_MT_add" is the one we care about
|
|
ui_name_cache[panel_type.bl_label] = bl_idname
|
|
elif panel_type.bl_rna.base.name == "UIList":
|
|
ui_name_cache[panel_type.bl_rna.name] = bl_idname
|
|
except:
|
|
pass
|
|
|
|
|
|
def replace_variables(value):
|
|
for key, new_value in variables.items():
|
|
value = value.replace("{" + key + "}", str(new_value))
|
|
return value
|
|
|
|
|
|
def is_x(number, x):
|
|
return abs(number - x) < 1e-5
|
|
|
|
|
|
def vectors_are_equal(v1, v2):
|
|
assert len(v1) == len(v2), f"Compared vectors are not equal length: {v1}, {v2}"
|
|
return all(is_x(v1[i], v2[i]) for i in range(len(v1)))
|
|
|
|
|
|
@given("an untestable scenario")
|
|
def an_untestable_scenario():
|
|
pass
|
|
|
|
|
|
@given("an empty Blender session")
|
|
@when("an empty Blender session is started")
|
|
def an_empty_blender_session():
|
|
IfcStore.purge()
|
|
if not PYTEST_BLENDER_NO_BACKGROUND:
|
|
bpy.ops.wm.read_homefile(app_template="", use_factory_startup=True)
|
|
if len(bpy.data.objects) > 0:
|
|
bpy.data.batch_remove(bpy.data.objects)
|
|
bpy.ops.outliner.orphans_purge(do_local_ids=True, do_linked_ids=True, do_recursive=True)
|
|
if len(bpy.data.materials) > 0:
|
|
bpy.data.batch_remove(bpy.data.materials)
|
|
|
|
# default project settings
|
|
bpy.context.scene.unit_settings.system = "METRIC"
|
|
bpy.context.scene.unit_settings.length_unit = "MILLIMETERS"
|
|
props = tool.Project.get_project_props()
|
|
props.template_file = "0"
|
|
tool.Blender.get_addon_preferences().should_play_chaching_sound = False
|
|
|
|
|
|
@given("an empty IFC project")
|
|
def an_empty_ifc_project():
|
|
an_empty_blender_session()
|
|
bpy.ops.bim.create_project()
|
|
|
|
|
|
@given("an empty IFC2X3 project")
|
|
def an_empty_ifc_2x3_project():
|
|
an_empty_blender_session()
|
|
props = tool.Project.get_project_props()
|
|
props.export_schema = "IFC2X3"
|
|
bpy.ops.bim.create_project()
|
|
|
|
|
|
@given(parsers.parse("I load previously saved IFC project"))
|
|
@when(parsers.parse("I load previously saved IFC project"))
|
|
@then(parsers.parse("I load previously saved IFC project"))
|
|
def load_previously_saved_ifc_project() -> None:
|
|
filepath = tool.Project.TEMP_PROJECT_PATH
|
|
bpy.ops.bim.load_project(filepath=filepath.__str__())
|
|
|
|
|
|
@given(parsers.parse("I save IFC project"))
|
|
@when(parsers.parse("I save IFC project"))
|
|
@then(parsers.parse("I save IFC project"))
|
|
def saving_ifc_project() -> None:
|
|
tool.Project.save_test_project()
|
|
|
|
|
|
@given("the Brickschema is stubbed")
|
|
def the_brickschema_is_stubbed():
|
|
# This makes things run faster since we don't need to load the entire brick schema
|
|
cwd = os.path.dirname(os.path.realpath(__file__))
|
|
BrickStore.schema = os.path.join(cwd, "..", "files", "BrickStub.ttl")
|
|
|
|
|
|
@given(parsers.parse('I look at the "{panel}" panel'))
|
|
@when(parsers.parse('I look at the "{panel}" panel'))
|
|
@then(parsers.parse('I look at the "{panel}" panel'))
|
|
def i_look_at_the_panel_panel(panel: str) -> None:
|
|
# Option to provide explicit panel name if panel names overlap.
|
|
panel_class = getattr(bpy.types, panel, None)
|
|
|
|
if panel_class is None:
|
|
global ui_name_cache
|
|
create_ui_name_cache()
|
|
if panel not in ui_name_cache:
|
|
assert False, f"Panel '{panel}' not found in `bpy.types` and in {ui_name_cache}"
|
|
panel_class = getattr(bpy.types, ui_name_cache[panel])
|
|
|
|
global panel_spy
|
|
panel_spy = PanelSpy(panel_class)
|
|
panel_spy.refresh_spy()
|
|
|
|
|
|
@given(parsers.parse('I open the "{name}" menu'))
|
|
@when(parsers.parse('I open the "{name}" menu'))
|
|
@then(parsers.parse('I open the "{name}" menu'))
|
|
def i_open_the_name_menu(name):
|
|
global ui_name_cache
|
|
global panel_spy
|
|
create_ui_name_cache()
|
|
if name not in ui_name_cache:
|
|
assert False, f"Menu {name} not found in {ui_name_cache}"
|
|
panel_spy = PanelSpy(getattr(bpy.types, ui_name_cache[name]))
|
|
panel_spy.refresh_spy()
|
|
|
|
|
|
@given(parsers.parse('I trigger "{operator}"'))
|
|
@when(parsers.parse('I trigger "{operator}"'))
|
|
@then(parsers.parse('I trigger "{operator}"'))
|
|
def i_trigger_operator(operator):
|
|
global ui_name_cache
|
|
global panel_spy
|
|
create_ui_name_cache()
|
|
if operator not in ui_name_cache:
|
|
assert False, f"Operator {operator} not found in {ui_name_cache}"
|
|
panel_spy = PanelSpy(getattr(bpy.types, ui_name_cache[operator]))
|
|
panel_spy.refresh_spy()
|
|
|
|
|
|
@given(parsers.parse('I see "{text}"'))
|
|
@when(parsers.parse('I see "{text}"'))
|
|
@then(parsers.parse('I see "{text}"'))
|
|
def i_see_text(text):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
assert [l for l in panel_spy.spied_labels if text in l], f"Text {text} not found in {panel_spy.spied_labels}"
|
|
|
|
|
|
@given(parsers.parse('there are "{n}" lists'))
|
|
@when(parsers.parse('there are "{n}" lists'))
|
|
@then(parsers.parse('there are "{n}" lists'))
|
|
def there_are_n_lists(n):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
if len(panel_spy.spied_lists) != int(n):
|
|
assert False, f"Actual number of lists {len(panel_spy.spied_lists)} not {n}"
|
|
|
|
|
|
@given(parsers.parse('I see "{text}" in the "{nth}" list'))
|
|
@when(parsers.parse('I see "{text}" in the "{nth}" list'))
|
|
@then(parsers.parse('I see "{text}" in the "{nth}" list'))
|
|
def i_see_text_in_the_nth_list(text, nth):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
nth = int("".join([c for c in nth if c.isnumeric()]))
|
|
if len(panel_spy.spied_lists) < nth:
|
|
assert False, f"{nth} list does not exist. Actual number of lists: {len(panel_spy.spied_lists)}"
|
|
debug = []
|
|
for i, template_list in enumerate(panel_spy.spied_lists):
|
|
if i + 1 != nth:
|
|
continue
|
|
for row in template_list.rows:
|
|
for p in row.spied_props:
|
|
debug.append(str(p))
|
|
if isinstance(p["value"], str) and text in p["value"]:
|
|
return True
|
|
for l in row.spied_labels:
|
|
debug.append(l)
|
|
if text in l:
|
|
return True
|
|
debug = "\n".join(debug)
|
|
assert False, f"Could not see '{text}' in any list. We saw:\n{debug}"
|
|
|
|
|
|
@given(parsers.parse('I don\'t see "{text}" in the "{nth}" list'))
|
|
@when(parsers.parse('I don\'t see "{text}" in the "{nth}" list'))
|
|
@then(parsers.parse('I don\'t see "{text}" in the "{nth}" list'))
|
|
def i_dont_see_text_in_the_nth_list(text, nth):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
nth = int("".join([c for c in nth if c.isnumeric()]))
|
|
if len(panel_spy.spied_lists) < nth:
|
|
assert False, f"{nth} list does not exist. Actual number of lists: {len(panel_spy.spied_lists)}"
|
|
debug = []
|
|
for i, template_list in enumerate(panel_spy.spied_lists):
|
|
if i + 1 != nth:
|
|
continue
|
|
for row in template_list.rows:
|
|
for l in row.spied_labels:
|
|
debug.append(l)
|
|
if text in l:
|
|
debug = "\n".join(debug)
|
|
assert False, f"We see saw '{text}' in the {nth} list but should not have. We saw:\n{debug}"
|
|
|
|
|
|
@given(parsers.parse('I click "{button}" in the row where I see "{text}" in the "{nth}" list'))
|
|
@when(parsers.parse('I click "{button}" in the row where I see "{text}" in the "{nth}" list'))
|
|
@then(parsers.parse('I click "{button}" in the row where I see "{text}" in the "{nth}" list'))
|
|
def i_click_button_in_the_row_where_i_see_text_in_the_nth_list(button: str, text: str, nth: str) -> None:
|
|
"""
|
|
:param button: The text or icon or name of the button/prop to click.
|
|
:param text: The text to search for in the row.
|
|
:param nth: E.g. "1st", "2nd", "5th".
|
|
"""
|
|
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
nth_ = int("".join([c for c in nth if c.isnumeric()]))
|
|
if len(panel_spy.spied_lists) < nth_:
|
|
assert False, f"{nth_} list does not exist. Actual number of lists: {len(panel_spy.spied_lists)}"
|
|
debug = []
|
|
for i, template_list in enumerate(panel_spy.spied_lists):
|
|
if i + 1 != nth_:
|
|
continue
|
|
for row in template_list.rows:
|
|
is_row = False
|
|
for l in row.spied_labels:
|
|
debug.append(l)
|
|
if text in l:
|
|
is_row = True
|
|
for p in row.spied_props:
|
|
debug.append(str(p))
|
|
if isinstance(p["value"], str) and text in p["value"]:
|
|
is_row = True
|
|
if is_row:
|
|
_i_click_button_on_panel(button, row)
|
|
# Success.
|
|
return
|
|
debug = "\n".join(debug)
|
|
assert False, f"Could not see '{text}' in any list. We saw:\n{debug}"
|
|
|
|
|
|
@given(parsers.parse('I select the row where I see "{text}" in the "{nth}" list'))
|
|
@when(parsers.parse('I select the row where I see "{text}" in the "{nth}" list'))
|
|
@then(parsers.parse('I select the row where I see "{text}" in the "{nth}" list'))
|
|
def i_select_the_row_where_i_see_text_in_the_nth_list(text, nth):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
nth = int("".join([c for c in nth if c.isnumeric()]))
|
|
if len(panel_spy.spied_lists) < nth:
|
|
assert False, f"{nth} list does not exist. Actual number of lists: {len(panel_spy.spied_lists)}"
|
|
debug = []
|
|
for i, template_list in enumerate(panel_spy.spied_lists):
|
|
if i + 1 != nth:
|
|
continue
|
|
for i, row in enumerate(template_list.rows):
|
|
is_row = False
|
|
for p in row.spied_props:
|
|
debug.append(str(p))
|
|
if isinstance(p["value"], str) and text in p["value"]:
|
|
is_row = True
|
|
for l in row.spied_labels:
|
|
debug.append(l)
|
|
if text in l:
|
|
is_row = True
|
|
if is_row:
|
|
template_list.set_active_index(i)
|
|
panel_spy.is_spy_dirty = True
|
|
return True
|
|
debug = "\n".join(debug)
|
|
assert False, f"Could not see '{text}' in any list. We saw:\n{debug}"
|
|
|
|
|
|
@given(parsers.parse('I don\'t see "{text}"'))
|
|
@when(parsers.parse('I don\'t see "{text}"'))
|
|
@then(parsers.parse('I don\'t see "{text}"'))
|
|
def i_dont_see_text(text):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
assert not [l for l in panel_spy.spied_labels if text in l], f"Text {text} found in {panel_spy.spied_labels}"
|
|
|
|
|
|
@given(parsers.parse('I don\'t see the "{name}" list'))
|
|
@when(parsers.parse('I don\'t see the "{name}" list'))
|
|
@then(parsers.parse('I don\'t see the "{name}" list'))
|
|
def i_dont_see_the_name_list(name):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
assert name not in [l.spied_data["listtype_name"] for l in panel_spy.spied_lists]
|
|
|
|
|
|
@given(parsers.parse('I see the "{prop}" property'))
|
|
@when(parsers.parse('I see the "{prop}" property'))
|
|
@then(parsers.parse('I see the "{prop}" property'))
|
|
def i_see_the_prop_property(prop):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
assert [
|
|
p for p in panel_spy.spied_props if prop in (p["name"], p["text"], p["icon"])
|
|
], f"Property {prop} not found in {pprint.pformat(panel_spy.spied_props)}"
|
|
|
|
|
|
@given(parsers.parse('I don\'t see the "{prop}" property'))
|
|
@when(parsers.parse('I don\'t see the "{prop}" property'))
|
|
@then(parsers.parse('I don\'t see the "{prop}" property'))
|
|
def i_dont_see_the_prop_property(prop):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
assert not [
|
|
p for p in panel_spy.spied_props if prop in (p["name"], p["text"], p["icon"])
|
|
], f"Property {prop} not found in {pprint.pformat(panel_spy.spied_props)}"
|
|
|
|
|
|
@given(parsers.parse('I see the "{prop}" property is "{value}"'))
|
|
@when(parsers.parse('I see the "{prop}" property is "{value}"'))
|
|
@then(parsers.parse('I see the "{prop}" property is "{value}"'))
|
|
def i_see_the_prop_property_is_value(prop, value):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
for spied_prop in panel_spy.spied_props:
|
|
if prop in (spied_prop["name"], spied_prop["text"], spied_prop["icon"]):
|
|
assert (
|
|
spied_prop["value"] == value
|
|
), f"Property {prop} value is not {value} - it is actually {spied_prop['value']}"
|
|
return
|
|
assert False, f"Property {prop} not found in {pprint.pformat(panel_spy.spied_props)}"
|
|
|
|
|
|
@given(parsers.parse('I set the "{prop}" property to "{value}"'))
|
|
@when(parsers.parse('I set the "{prop}" property to "{value}"'))
|
|
@then(parsers.parse('I set the "{prop}" property to "{value}"'))
|
|
def i_set_the_prop_property_to_value(prop: str, value: str):
|
|
"""
|
|
:param prop: Could be either property name, property text, property icon
|
|
or property index (e.g. "1st", "2nd", "5th").
|
|
:param value:
|
|
For boolean propeties - 'TRUE' or 'FALSE'.
|
|
"""
|
|
value = value.strip()
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
is_nth = False
|
|
if prop[0].isnumeric() and prop.endswith(("st", "nd", "th")):
|
|
is_nth = True
|
|
for nth, spied_prop in enumerate(panel_spy.spied_props):
|
|
if is_nth and nth != int(prop[:-2]) - 1:
|
|
continue
|
|
if not is_nth and prop not in (spied_prop["name"], spied_prop["text"], spied_prop["icon"]):
|
|
continue
|
|
if spied_prop["prop_type"] == "BOOLEAN":
|
|
if value == "TRUE":
|
|
setattr(spied_prop["props"], spied_prop["name"], True)
|
|
elif value == "FALSE":
|
|
setattr(spied_prop["props"], spied_prop["name"], False)
|
|
else:
|
|
assert False, f"Unexpected value for BOOLEAN property: '{value}'. Allowed values: TRUE, FALSE."
|
|
elif spied_prop["prop_type"] == "FLOAT":
|
|
setattr(spied_prop["props"], spied_prop["name"], float(value))
|
|
elif spied_prop["prop_type"] == "INT":
|
|
setattr(spied_prop["props"], spied_prop["name"], int(value))
|
|
elif spied_prop["prop_type"] == "ENUM":
|
|
enum_identifier = [i for i in spied_prop["enum_items"] if i is not None and i[1] == value]
|
|
if not enum_identifier:
|
|
assert False, f"Could not find value {value} in enum {spied_prop['enum_items']}"
|
|
setattr(spied_prop["props"], spied_prop["name"], enum_identifier[0][0])
|
|
elif spied_prop["prop_type"] == "POINTER":
|
|
setattr(spied_prop["props"], spied_prop["name"], bpy.data.objects.get(value))
|
|
else:
|
|
setattr(spied_prop["props"], spied_prop["name"], value)
|
|
panel_spy.is_spy_dirty = True
|
|
return
|
|
debug = "\n".join([f"{i} {v}" for i, v in enumerate(panel_spy.spied_props)])
|
|
assert False, f"Property {prop} not found in:\n{debug}"
|
|
|
|
|
|
@then(parsers.parse('The "{name}" list has {total} items'))
|
|
def the_name_list_has_total_items(name, total):
|
|
total = int(total)
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
for template_list in panel_spy.spied_lists:
|
|
if name == template_list.spied_data["listtype_name"]:
|
|
actual_total = len(template_list.items)
|
|
assert actual_total == total, f"The actual number of items in {name} is {actual_total} not {total}"
|
|
return
|
|
assert False, f"List {name} not found in {panel_spy.spied_lists}"
|
|
|
|
|
|
@given(parsers.parse('I select the "{item_name}" item in the "{list_name}" list'))
|
|
@when(parsers.parse('I select the "{item_name}" item in the "{list_name}" list'))
|
|
@then(parsers.parse('I can select the "{item_name}" item in the "{list_name}" list'))
|
|
def i_select_the_item_name_item_in_the_list_name_list(item_name: str, list_name: str) -> None:
|
|
"""
|
|
:param item_name: The ``.name`` of the item to select.
|
|
:param list_name: List type name, e.g. ``BIM_UL_containers_manager``.
|
|
"""
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
for template_list in panel_spy.spied_lists:
|
|
if list_name == template_list.spied_data["listtype_name"]:
|
|
item_names: list[str] = []
|
|
for i, item in enumerate(template_list.items):
|
|
item_names.append(item.name)
|
|
if item.name == item_name:
|
|
template_list.set_active_index(i)
|
|
panel_spy.is_spy_dirty = True
|
|
return
|
|
assert False, f"Could not find item {item_name} in {item_names}"
|
|
assert False, f"List {list_name} not found in {panel_spy.spied_lists}"
|
|
|
|
|
|
@when("I load a new pset template file")
|
|
def i_load_a_new_pset_template_file():
|
|
global RELOAD_EPSET_DRAWING
|
|
RELOAD_EPSET_DRAWING = True
|
|
props = tool.PsetTemplate.get_pset_template_props()
|
|
IfcStore.pset_template_path = props.pset_template_files
|
|
IfcStore.pset_template_file = ifcopenshell.open(IfcStore.pset_template_path)
|
|
|
|
|
|
@given("I create default MEP types")
|
|
def i_create_default_mep_types():
|
|
model_props = tool.Model.get_model_props()
|
|
|
|
# add couple segments types
|
|
i_trigger_operator("Add Element")
|
|
i_set_the_prop_property_to_value("Name", "RECT1")
|
|
i_set_the_prop_property_to_value("Class", "IfcDuctSegmentType")
|
|
i_set_the_prop_property_to_value("Representation", "Rectangular Distribution Segment")
|
|
i_click_button("OK")
|
|
|
|
i_trigger_operator("Add Element")
|
|
i_set_the_prop_property_to_value("Name", "CIRCLE1")
|
|
i_set_the_prop_property_to_value("Class", "IfcDuctSegmentType")
|
|
i_set_the_prop_property_to_value("Representation", "Circular Distribution Segment")
|
|
i_click_button("OK")
|
|
|
|
# add an actuator type
|
|
i_trigger_operator("Add Element")
|
|
i_set_the_prop_property_to_value("Name", "ACTUATOR")
|
|
i_set_the_prop_property_to_value("Class", "IfcActuatorType")
|
|
i_set_the_prop_property_to_value("Representation", "Custom Tessellation")
|
|
i_click_button("OK")
|
|
|
|
with bpy.context.temp_override(active_object=bpy.data.objects["IfcActuatorType/ACTUATOR"]):
|
|
bpy.ops.bim.add_port()
|
|
# port at cube's left side
|
|
bpy.data.objects["IfcDistributionPort/Port"].location = (-0.5, 0, 0)
|
|
bpy.ops.bim.hide_ports()
|
|
|
|
|
|
@given("I add a cube")
|
|
@when("I add a cube")
|
|
def i_add_a_cube():
|
|
bpy.ops.mesh.primitive_cube_add()
|
|
|
|
|
|
@given("I add an empty")
|
|
@when("I add an empty")
|
|
def i_add_an_empty():
|
|
bpy.ops.object.empty_add()
|
|
|
|
|
|
@given("I add a sun")
|
|
@when("I add a sun")
|
|
def i_add_a_sun():
|
|
bpy.ops.object.light_add(type="SUN")
|
|
|
|
|
|
@given("I add a material")
|
|
@when("I add a material")
|
|
def i_add_a_material():
|
|
bpy.context.active_object.active_material = bpy.data.materials.new("Material")
|
|
|
|
|
|
@given(parsers.parse('I add a new item to "{collection}"'))
|
|
@when(parsers.parse('I add a new item to "{collection}"'))
|
|
def i_add_a_new_collection_item(collection):
|
|
try:
|
|
eval(f"bpy.context.{collection}.add()")
|
|
except:
|
|
assert False, "Collection does not exist"
|
|
|
|
|
|
@given(parsers.parse('I make the collection "{name}" visible'))
|
|
@when(parsers.parse('I make the collection "{name}" visible'))
|
|
def i_make_the_collection_name_visible(name):
|
|
tool.Blender.get_layer_collection(bpy.data.collections.get(name)).hide_viewport = False
|
|
|
|
|
|
@given(parsers.parse('the material "{name}" colour is set to "{colour}"'))
|
|
@when(parsers.parse('the material "{name}" colour is set to "{colour}"'))
|
|
def the_material_name_colour_is_set_to_colour(name, colour):
|
|
obj = the_material_name_exists(name)
|
|
obj.diffuse_color = [float(c) for c in colour.split(",")]
|
|
|
|
|
|
@given("I add an array modifier")
|
|
def i_add_an_array_modifier():
|
|
bpy.ops.object.modifier_add(type="ARRAY")
|
|
|
|
|
|
@given(parsers.parse('I add a cube of size "{size}" at "{location}"'))
|
|
@when(parsers.parse('I add a cube of size "{size}" at "{location}"'))
|
|
def i_add_a_cube_of_size_size_at_location(size, location):
|
|
bpy.ops.mesh.primitive_cube_add(size=float(size), location=[float(co) for co in location.split(",")])
|
|
|
|
|
|
@given(parsers.parse('I add a plane of size "{size}" at "{location}"'))
|
|
@when(parsers.parse('I add a plane of size "{size}" at "{location}"'))
|
|
def i_add_a_plane_of_size_size_at_location(size, location):
|
|
bpy.ops.mesh.primitive_plane_add(size=float(size), location=[float(co) for co in location.split(",")])
|
|
|
|
|
|
@then(parsers.parse('I expect an error "{error_msg}" when "{function}"'))
|
|
def i_expect_an_error_msg_when_function(error_msg, function):
|
|
try:
|
|
exec(function)
|
|
except Exception as e:
|
|
actual_error_msg = str(e).strip()
|
|
if str(e).strip() != error_msg:
|
|
traceback.print_exc()
|
|
msg = f"Got different exception running {function} - '{actual_error_msg}' instead of '{error_msg}'"
|
|
assert False, msg
|
|
return
|
|
assert False, f"Function {function} ran without exception '{error_msg}'"
|
|
|
|
|
|
@then(parsers.parse('I press "{operator}" and expect error "{error_msg}"'))
|
|
def i_press_operator_and_expect_error(operator, error_msg):
|
|
operator = replace_variables(operator)
|
|
try:
|
|
if "(" in operator:
|
|
exec(f"bpy.ops.{operator}")
|
|
else:
|
|
exec(f"bpy.ops.{operator}()")
|
|
except Exception as e:
|
|
actual_error_msg = str(e).strip()
|
|
if str(e).strip() != error_msg:
|
|
traceback.print_exc()
|
|
msg = f"Got different exception running bpy.ops.{operator} - '{actual_error_msg}' instead of '{error_msg}'"
|
|
assert False, msg
|
|
return
|
|
assert False, f"Operator bpy.ops.{operator} ran without exception '{error_msg}'"
|
|
|
|
|
|
# TODO: We should rename 'I press' to 'I run' or 'I execute'
|
|
# to avoid confusion with 'I click'.
|
|
@given(parsers.parse('I press "{operator}"'))
|
|
@when(parsers.parse('I press "{operator}"'))
|
|
def i_press_operator(operator: str) -> types.NoneType:
|
|
operator = replace_variables(operator)
|
|
try:
|
|
if "(" in operator:
|
|
exec(f"bpy.ops.{operator}")
|
|
else:
|
|
exec(f"bpy.ops.{operator}()")
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
assert False, f"Failed to run operator bpy.ops.{operator} because of {e}"
|
|
|
|
|
|
def _i_click_button_on_panel(button: str, panel_spy: PanelSpy) -> None:
|
|
for spied_operator in panel_spy.spied_operators:
|
|
if spied_operator["text"] == button or spied_operator["icon"] == button:
|
|
spied_operator["operator"]("INVOKE_DEFAULT", **spied_operator["kwargs"])
|
|
panel_spy.is_spy_dirty = True
|
|
return
|
|
# Users can also "click" on booleans to toggle them
|
|
for spied_prop in panel_spy.spied_props:
|
|
if button in (spied_prop["name"], spied_prop["text"], spied_prop["icon"]):
|
|
val = getattr(spied_prop["props"], spied_prop["name"])
|
|
setattr(spied_prop["props"], spied_prop["name"], not bool(val))
|
|
panel_spy.is_spy_dirty = True
|
|
return
|
|
if button == "OK" and panel_spy.blender_panel.bl_rna.base.name == "Operator":
|
|
# Clicked confirm on an operator's draw dialog
|
|
return i_press_operator(panel_spy.blender_panel.bl_idname)
|
|
debug = "\n".join([f"{i} {v}" for i, v in enumerate(panel_spy.spied_operators)])
|
|
debug_props = pprint.pformat(panel_spy.spied_props)
|
|
debug += f"\nHere is the text we see:\n{panel_spy.spied_labels}\n... and props:\n {debug_props}"
|
|
assert False, f"Could not find {button}:\n{debug}"
|
|
|
|
|
|
@given(parsers.parse('I click "{button}"'))
|
|
@when(parsers.parse('I click "{button}"'))
|
|
@then(parsers.parse('I click "{button}"'))
|
|
def i_click_button(button):
|
|
"""
|
|
:param button: The text or icon of the button to click.
|
|
"""
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
_i_click_button_on_panel(button, panel_spy)
|
|
|
|
|
|
@given(parsers.parse('I click the "{button}" after the text "{text}"'))
|
|
@when(parsers.parse('I click the "{button}" after the text "{text}"'))
|
|
@then(parsers.parse('I click the "{button}" after the text "{text}"'))
|
|
def i_click_the_button_after_the_text_text(button, text):
|
|
assert panel_spy
|
|
panel_spy.refresh_spy()
|
|
for spied_operator in panel_spy.spied_operators:
|
|
if spied_operator["after"] == text:
|
|
if spied_operator["text"] == button or spied_operator["icon"] == button:
|
|
spied_operator["operator"]("INVOKE_DEFAULT", **spied_operator["kwargs"])
|
|
panel_spy.is_spy_dirty = True
|
|
return
|
|
debug = "\n".join([f"{i} {v}" for i, v in enumerate(panel_spy.spied_operators)])
|
|
debug += f"\nHere is the text we see: {panel_spy.spied_labels}"
|
|
assert False, f"Could not find {button}:\n{debug}"
|
|
|
|
|
|
@given(parsers.parse('I click "{button}" and expect error "{error_msg}"'))
|
|
@when(parsers.parse('I click "{button}" and expect error "{error_msg}"'))
|
|
def i_click_button_and_expect_error_error_msg(button, error_msg):
|
|
try:
|
|
i_click_button(button)
|
|
except Exception as e:
|
|
actual_error_msg = str(e).strip()
|
|
if str(e).strip() != error_msg:
|
|
traceback.print_exc()
|
|
msg = f"Got different exception clickign {button} - '{actual_error_msg}' instead of '{error_msg}'"
|
|
assert False, msg
|
|
return
|
|
assert False, f"No error message {error_msg} raised when I pressed {button}"
|
|
|
|
|
|
@given(parsers.parse('I evaluate expression "{expression}"'))
|
|
@when(parsers.parse('I evaluate expression "{expression}"'))
|
|
def i_evaluate_expression(expression):
|
|
expression = replace_variables(expression)
|
|
exec(expression)
|
|
|
|
|
|
@given("I duplicate the selected objects")
|
|
@when("I duplicate the selected objects")
|
|
def i_duplicate_the_selected_objects():
|
|
bpy.ops.bim.override_object_duplicate_move()
|
|
bonsai.bim.handler.active_object_callback()
|
|
|
|
|
|
@when("I duplicate linked aggregate the selected objects")
|
|
def i_duplicate_linked_aggregate_the_selected_objects():
|
|
bpy.ops.bim.object_duplicate_move_linked_aggregate()
|
|
bonsai.bim.handler.active_object_callback()
|
|
|
|
|
|
@when("I refresh linked aggregate the selected object")
|
|
def i_refresh_the_selected_objects():
|
|
bpy.ops.bim.refresh_linked_aggregate()
|
|
bonsai.bim.handler.active_object_callback()
|
|
|
|
|
|
@given("I deselect all objects")
|
|
@when("I deselect all objects")
|
|
def i_deselect_all_objects():
|
|
bpy.context.view_layer.objects.active = None
|
|
bpy.ops.object.select_all(action="DESELECT")
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" is selected'))
|
|
@when(parsers.parse('the object "{name}" is selected'))
|
|
@given(parsers.parse('I select the object "{name}"'))
|
|
@when(parsers.parse('I select the object "{name}"'))
|
|
def the_object_name_is_selected(name):
|
|
i_deselect_all_objects()
|
|
additionally_the_object_name_is_selected(name)
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is selected'))
|
|
def then_the_object_name_is_selected(name):
|
|
obj = the_object_name_exists(name)
|
|
assert obj in bpy.context.selected_objects
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is not selected'))
|
|
def then_the_object_name_is_not_selected(name):
|
|
obj = the_object_name_exists(name)
|
|
assert obj not in bpy.context.selected_objects
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" is rotated by "{rotation_deg}" deg'))
|
|
@when(parsers.parse('the object "{name}" is rotated by "{rotation_deg}" deg'))
|
|
def the_object_name_is_rotated_by(name, rotation_deg):
|
|
rotation_deg = [radians(float(rot)) for rot in rotation_deg.split(",")]
|
|
obj = the_object_name_exists(name)
|
|
obj.rotation_euler[0] += rotation_deg[0]
|
|
obj.rotation_euler[1] += rotation_deg[1]
|
|
obj.rotation_euler[2] += rotation_deg[2]
|
|
bpy.context.view_layer.update() # make sure matrix is updated
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" is moved to "{location}"'))
|
|
@when(parsers.parse('the object "{name}" is moved to "{location}"'))
|
|
def the_object_name_is_moved_to_location(name, location):
|
|
location = [float(co) for co in location.split(",")]
|
|
obj = the_object_name_exists(name)
|
|
obj.matrix_world.translation = location
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" is scaled to "{scale}"'))
|
|
@when(parsers.parse('the object "{name}" is scaled to "{scale}"'))
|
|
def the_object_name_is_scaled_to_scale(name, scale):
|
|
the_object_name_exists(name).scale *= float(scale)
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" is placed in the collection "{collection}"'))
|
|
@when(parsers.parse('the object "{name}" is placed in the collection "{collection}"'))
|
|
def the_object_name_is_placed_in_the_collection_collection(name: str, collection: str) -> None:
|
|
obj = the_object_name_exists(name)
|
|
[c.objects.unlink(obj) for c in obj.users_collection]
|
|
bpy.data.collections.get(collection).objects.link(obj)
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is placed in the collection "{collection}"'))
|
|
def then_the_object_name_is_placed_in_the_collection_collection(name: str, collection: str) -> None:
|
|
obj = the_object_name_exists(name)
|
|
assert obj in bpy.data.collections.get(collection).objects[:]
|
|
|
|
|
|
@given(parsers.parse('additionally the object "{name}" is selected'))
|
|
@when(parsers.parse('additionally the object "{name}" is selected'))
|
|
def additionally_the_object_name_is_selected(name):
|
|
obj = bpy.context.scene.objects.get(name)
|
|
if not obj:
|
|
total = len(bpy.context.scene.objects)
|
|
debug = "\n".join([o.name for o in bpy.context.scene.objects])
|
|
assert False, f'The object "{name}" could not be selected. Available objects ({total} total):\n{debug}'
|
|
bpy.context.view_layer.objects.active = obj
|
|
obj.select_set(True)
|
|
|
|
|
|
@given(parsers.parse('I rename the object "{name1}" to "{name2}"'))
|
|
@when(parsers.parse('I rename the object "{name1}" to "{name2}"'))
|
|
def i_rename_the_object_name1_to_name2(name1, name2):
|
|
the_object_name_exists(name1).name = name2
|
|
|
|
|
|
@given(parsers.parse('I set "{prop}" to "{value}"'))
|
|
@when(parsers.parse('I set "{prop}" to "{value}"'))
|
|
def i_set_prop_to_value(prop: str, value: str) -> None:
|
|
value = replace_variables(value)
|
|
try:
|
|
eval(f"bpy.context.{prop}")
|
|
except:
|
|
assert False, f"Property {prop} does not exist when trying to set to value {value}"
|
|
try:
|
|
exec(f'bpy.context.{prop} = r"{value}"')
|
|
except:
|
|
exec(f"bpy.context.{prop} = {value}")
|
|
|
|
|
|
@given(parsers.parse('I set "{prop}" to ""'))
|
|
@when(parsers.parse('I set "{prop}" to ""'))
|
|
def i_set_prop_to_empty_string(prop):
|
|
try:
|
|
eval(f"bpy.context.{prop}")
|
|
except:
|
|
assert False, f"Property {prop} does not exist"
|
|
try:
|
|
exec(f'bpy.context.{prop} = r""')
|
|
except:
|
|
pass
|
|
|
|
|
|
@when(parsers.parse('I am on frame "{number}"'))
|
|
def i_am_on_frame_number(number):
|
|
bpy.context.scene.frame_set(int(number))
|
|
|
|
|
|
@given("I delete the selected objects")
|
|
@when("I delete the selected objects")
|
|
def i_delete_the_selected_objects():
|
|
bpy.ops.bim.override_object_delete()
|
|
|
|
|
|
@given(parsers.parse('the variable "{key}" is "{value}"'))
|
|
@when(parsers.parse('the variable "{key}" is "{value}"'))
|
|
@then(parsers.parse('the variable "{key}" is "{value}"'))
|
|
def the_variable_key_is_value(key, value):
|
|
variables[key] = eval(replace_variables(value))
|
|
|
|
|
|
@then("nothing happens")
|
|
def nothing_happens():
|
|
pass
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" exists'))
|
|
@when(parsers.parse('the object "{name}" exists'))
|
|
@then(parsers.parse('the object "{name}" exists'))
|
|
def the_object_name_exists(name: str) -> bpy.types.Object:
|
|
# Some objects from linked collections may share the same name. This disambiguates them.
|
|
if name.startswith("Col:"):
|
|
_, collection_name, name = name.split(":")
|
|
obj = bpy.data.collections.get(collection_name).objects.get(name)
|
|
else:
|
|
obj = bpy.data.objects.get(name)
|
|
if not obj:
|
|
debug = "\n".join([o.name for o in bpy.data.objects])
|
|
assert False, f'The object "{name}" does not exist:\n{debug}'
|
|
return obj
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" does not exist'))
|
|
def the_object_name_does_not_exist(name) -> None:
|
|
obj = bpy.data.objects.get(name)
|
|
assert obj is None, f'The object "{name}" exists'
|
|
|
|
|
|
@given(parsers.parse('the collection "{name}" exists'))
|
|
@when(parsers.parse('the collection "{name}" exists'))
|
|
@then(parsers.parse('the collection "{name}" exists'))
|
|
def the_collection_name_exists(name) -> bpy.types.Collection:
|
|
obj = bpy.data.collections.get(name)
|
|
if not obj:
|
|
assert False, f'The collection "{name}" does not exist'
|
|
return obj
|
|
|
|
|
|
@then(parsers.parse('the collection "{name}" is selectable'))
|
|
def the_collection_name_is_selectable(name: str) -> None:
|
|
col = the_collection_name_exists(name)
|
|
assert col.hide_select == False
|
|
|
|
|
|
@then(parsers.parse('the collection "{name}" is unselectable'))
|
|
def the_collection_name_is_unselectable(name: str) -> None:
|
|
col = the_collection_name_exists(name)
|
|
assert col.hide_select == True
|
|
|
|
|
|
@then(parsers.parse('the collection "{name}" exists in viewlayer'))
|
|
def the_collection_exists_in_viewlayer(name: str) -> bpy.types.LayerCollection:
|
|
col = the_collection_name_exists(name)
|
|
results = tool.Blender.get_layer_collections_mapping([col])
|
|
if not (layer_collection := results.get(col, None)):
|
|
assert False, f'The collection "{name}" is not present in the current viewlayer'
|
|
return layer_collection
|
|
|
|
|
|
@then(parsers.parse('the collection "{name}" exclude status is "{exclude}"'))
|
|
def the_collection_exclude_status_is(name: str, exclude: str) -> None:
|
|
layer = the_collection_exists_in_viewlayer(name)
|
|
assert layer.exclude == (exclude == "True")
|
|
|
|
|
|
@then(parsers.parse('the object "{name1}" and "{name2}" are different elements'))
|
|
def the_object_name1_and_name2_are_different_elements(name1, name2):
|
|
ifc = an_ifc_file_exists()
|
|
element1 = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name1)))
|
|
element2 = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name2)))
|
|
assert element1 != element2, f"Objects {name1} and {name2} have same elements {element1} and {element2}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has a body of "{value}"'))
|
|
def the_object_name_has_a_body_of_value(name, value):
|
|
assert the_object_name_exists(name).data.body == value
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" has a "{type}" representation of "{context}"'))
|
|
@then(parsers.parse('the object "{name}" has a "{type}" representation of "{context}"'))
|
|
def the_object_name_has_a_representation_type_of_context(name, type, context):
|
|
ifc = an_ifc_file_exists()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
context, subcontext, target_view = context.split("/")
|
|
rep = ifcopenshell.util.representation.get_representation(element, context, subcontext or None, target_view or None)
|
|
assert rep
|
|
assert rep.RepresentationType == type, f"The object {name} does not have a {type} representation"
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" data is a "{type}" representation of "{context}"'))
|
|
@then(parsers.parse('the object "{name}" data is a "{type}" representation of "{context}"'))
|
|
def the_object_name_data_is_a_type_representation_of_context(name, type, context):
|
|
ifc = an_ifc_file_exists()
|
|
context, subcontext, target_view = context.split("/")
|
|
rep = ifc.by_id(tool.Geometry.get_mesh_props(the_object_name_exists(name).data).ifc_definition_id)
|
|
assert rep
|
|
assert rep.RepresentationType == type, f"The object {name} is not a {type} representation"
|
|
assert rep.ContextOfItems.ContextType == context
|
|
assert rep.ContextOfItems.ContextIdentifier == subcontext
|
|
assert rep.ContextOfItems.TargetView == target_view
|
|
|
|
|
|
@then(parsers.parse('the material "{name}" exists'))
|
|
def the_material_name_exists(name: str) -> bpy.types.Material:
|
|
obj = bpy.data.materials.get(name)
|
|
if not obj:
|
|
assert False, f'The material "{name}" does not exist'
|
|
return obj
|
|
|
|
|
|
@then(parsers.parse('the material "{name}" does not exist'))
|
|
def the_material_name_does_not_exist(name):
|
|
assert bpy.data.materials.get(name) is None, "Material exists"
|
|
|
|
|
|
@then(parsers.parse('the mesh "{name}" does not exist'))
|
|
def the_mesh_name_does_not_exist(name: str) -> None:
|
|
assert bpy.data.meshes.get(name) is None, f"Mesh '{name}' exists"
|
|
|
|
|
|
def get_ifc_material_by_name(name: str) -> Union[ifcopenshell.entity_instance, None]:
|
|
ifc_file = tool.Ifc.get()
|
|
material = next((m for m in ifc_file.by_type("IfcMaterial") if m.Name == name), None)
|
|
return material
|
|
|
|
|
|
@then(parsers.parse('the IFC material "{name}" exists'))
|
|
def the_ifc_material_name_exists(name: str) -> ifcopenshell.entity_instance:
|
|
material = get_ifc_material_by_name(name)
|
|
if not material:
|
|
assert False, f'The IFC material "{name}" does not exist'
|
|
return material
|
|
|
|
|
|
@then(parsers.parse('the material "{name}" does not exist'))
|
|
def the_ifc_material_name_does_not_exist(name):
|
|
assert get_ifc_material_by_name(name) is None, "IFC Material exists"
|
|
|
|
|
|
@then("an IFC file does not exist")
|
|
def an_ifc_file_does_not_exist():
|
|
ifc = tool.Ifc.get()
|
|
if ifc:
|
|
assert False, "An IFC is available"
|
|
|
|
|
|
@then("an IFC file exists")
|
|
def an_ifc_file_exists():
|
|
ifc = tool.Ifc.get()
|
|
if not ifc:
|
|
assert False, "No IFC file is available"
|
|
return ifc
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" should display as "{mode}"'))
|
|
def the_object_name_should_display_as_mode(name, mode):
|
|
obj = the_object_name_exists(name)
|
|
assert obj.display_type == mode
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is voided by "{void}"'))
|
|
def the_object_name_is_voided_by_void(name, void):
|
|
ifc = tool.Ifc.get()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
assert any(rel for rel in element.HasOpenings if rel.RelatedOpeningElement.Name == void), "No void found"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is not voided by "{void}"'))
|
|
def the_object_name_is_not_voided_by_void(name, void):
|
|
try:
|
|
the_object_name_is_voided_by_void(name, void)
|
|
except AssertionError:
|
|
return
|
|
assert False, "A void was found"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is not voided'))
|
|
def the_object_name_is_not_voided(name):
|
|
ifc = tool.Ifc.get()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
assert not element.HasOpenings, "A void was found"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is a void'))
|
|
def the_object_name_is_a_void(name):
|
|
ifc = tool.Ifc.get()
|
|
obj = the_object_name_exists(name)
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(obj))
|
|
assert any(element.VoidsElements), "No void was found"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is not a void'))
|
|
def the_object_name_is_not_a_void(name):
|
|
try:
|
|
the_object_name_is_a_void(name)
|
|
except AssertionError:
|
|
return
|
|
assert False, "A void was found"
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" is visible'))
|
|
def given_the_object_name_is_visible(name):
|
|
obj = the_object_name_exists(name)
|
|
obj.hide_set(False)
|
|
|
|
|
|
@given(parsers.parse('the object "{name}" is not visible'))
|
|
def given_the_object_name_is_not_visible(name):
|
|
obj = the_object_name_exists(name)
|
|
obj.hide_set(True)
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is visible'))
|
|
def the_object_name_is_visible(name):
|
|
obj = the_object_name_exists(name)
|
|
assert obj.hide_get() == False
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is not visible'))
|
|
def the_object_name_is_not_visible(name):
|
|
obj = the_object_name_exists(name)
|
|
assert obj.hide_get() == True
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is an "{ifc_class}"'))
|
|
def the_object_name_is_an_ifc_class(name, ifc_class):
|
|
ifc = an_ifc_file_exists()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
assert element.is_a(ifc_class), f'Object "{name}" is an {element.is_a()}'
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is not an IFC element'))
|
|
def the_object_name_is_not_an_ifc_element(name):
|
|
obj = the_object_name_exists(name)
|
|
ifc_definition_id = tool.Blender.get_ifc_definition_id(obj)
|
|
assert ifc_definition_id == 0, f"The object {obj} has an ID of {ifc_definition_id}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has no data'))
|
|
def the_object_name_has_no_data(name):
|
|
assert the_object_name_exists(name).data is None
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has data which is an IFC representation'))
|
|
def the_object_name_has_ifc_representation_data(name):
|
|
id = tool.Geometry.get_mesh_props(the_object_name_exists(name).data).ifc_definition_id
|
|
assert id != 0, f"The ID is {id}"
|
|
|
|
|
|
@then(parsers.parse('the material "{name}" is an IFC material'))
|
|
def the_material_name_is_an_ifc_material(name):
|
|
obj = the_material_name_exists(name)
|
|
ifc_definition_id = tool.Blender.get_ifc_definition_id(obj)
|
|
assert ifc_definition_id != 0, f"The material {obj} has no ID: {ifc_definition_id}"
|
|
|
|
|
|
@then(parsers.parse('the material "{name}" is not an IFC material'))
|
|
def the_material_name_is_not_an_ifc_material(name):
|
|
obj = the_material_name_exists(name)
|
|
ifc_definition_id = tool.Blender.get_ifc_definition_id(obj)
|
|
assert ifc_definition_id == 0, f"The material {obj} has an ID of {ifc_definition_id}"
|
|
|
|
|
|
@then(parsers.parse('the material "{name}" is an IFC style'))
|
|
def the_material_name_is_an_ifc_style(name):
|
|
obj = the_material_name_exists(name)
|
|
ifc_definition_id = tool.Blender.get_ifc_definition_id(obj)
|
|
assert ifc_definition_id != 0, f"The material {obj} has a style ID of {ifc_definition_id}"
|
|
|
|
|
|
@then(parsers.parse('the material "{name}" is not an IFC style'))
|
|
def the_material_name_is_not_an_ifc_style(name):
|
|
obj = the_material_name_exists(name)
|
|
ifc_definition_id = tool.Blender.get_ifc_definition_id(obj)
|
|
assert ifc_definition_id == 0, f"The material {obj} has a style ID of {ifc_definition_id}"
|
|
|
|
|
|
@then(parsers.parse('the material "{name}" colour is "{colour}"'))
|
|
def then_the_material_name_colour_is_set_to_colour(name, colour):
|
|
diffuse_color = list(the_material_name_exists(name).diffuse_color)
|
|
assert diffuse_color == [float(c) for c in colour.split(",")], f"The colour is {diffuse_color}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has "{number}" vertices'))
|
|
def the_object_name_has_number_vertices(name, number):
|
|
total = len(the_object_name_exists(name).data.vertices)
|
|
assert total == int(number), f"We found {total} vertices"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is filled by "{name2}"'))
|
|
def the_object_name_is_filled_by_filling(name, name2):
|
|
ifc = tool.Ifc.get()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
debug = {}
|
|
for rel in ifcopenshell.util.element.get_openings(element):
|
|
filling = None
|
|
opening = rel.RelatedOpeningElement
|
|
for rel2 in opening.HasFillings or []:
|
|
filling = rel2.RelatedBuildingElement
|
|
break
|
|
debug[opening] = filling
|
|
filling_obj = tool.Ifc.get_object(filling)
|
|
if filling_obj and filling_obj.name == name2:
|
|
return True
|
|
debug = "\n".join([f"{k} filled by {v}" for k, v in debug.items()])
|
|
assert False, f"Object {name} is not filled by {name2}.\n{debug}"
|
|
|
|
|
|
@then(parsers.parse('the void "{name}" is filled by "{filling}"'))
|
|
def the_void_name_is_filled_by_filling(name, filling):
|
|
ifc = tool.Ifc.get()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
assert any(rel.RelatedBuildingElement.Name == filling for rel in element.HasFillings), "No filling found"
|
|
|
|
|
|
@then(parsers.parse('the void "{name}" is not filled by "{filling}"'))
|
|
def the_void_name_is_not_filled_by_filling(name, filling):
|
|
try:
|
|
the_void_name_is_filled_by_filling(name, filling)
|
|
except AssertionError:
|
|
return
|
|
assert False, "A filling was found"
|
|
|
|
|
|
@when(parsers.parse('the object "{name}" is not a filling'))
|
|
@then(parsers.parse('the object "{name}" is not a filling'))
|
|
def the_object_name_is_not_a_filling(name):
|
|
ifc = tool.Ifc.get()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
assert not any(element.FillsVoids), "A filling was found"
|
|
|
|
|
|
@then(parsers.parse('"{prop}" is "{value}"'))
|
|
def prop_is_value(prop, value):
|
|
prop = replace_variables(prop)
|
|
value = replace_variables(value)
|
|
is_value = False
|
|
try:
|
|
exec(f'assert bpy.context.{prop} == "{value}"')
|
|
is_value = True
|
|
except:
|
|
try:
|
|
exec(f"assert bpy.context.{prop} == {value}")
|
|
is_value = True
|
|
except:
|
|
try:
|
|
exec(f"assert list(bpy.context.{prop}) == {value}")
|
|
is_value = True
|
|
except:
|
|
try:
|
|
exec(f"assert vectors_are_equal(bpy.context.{prop}, {value})")
|
|
is_value = True
|
|
except:
|
|
pass
|
|
if not is_value:
|
|
print(f"bpy.context.{prop}")
|
|
actual_value = eval(f"bpy.context.{prop}")
|
|
assert False, f"Value is {actual_value}"
|
|
|
|
|
|
@then(parsers.parse('"{prop}" is roughly "{value}"'))
|
|
def prop_is_roughly_value(prop, value):
|
|
prop = replace_variables(prop)
|
|
value = replace_variables(value)
|
|
is_value = False
|
|
try:
|
|
exec(f'assert round(bpy.context.{prop}, 3) == "{value}"')
|
|
is_value = True
|
|
except:
|
|
try:
|
|
exec(f"assert round(bpy.context.{prop}, 3) == {value}")
|
|
is_value = True
|
|
except:
|
|
pass
|
|
if not is_value:
|
|
print(f"bpy.context.{prop}")
|
|
actual_value = round(eval(f"bpy.context.{prop}"), 3)
|
|
assert False, f"Value is {actual_value}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has a cartesian point offset of "{offset}"'))
|
|
def the_object_name_has_a_cartesian_point_offset_of_offset(name: str, offset: str) -> None:
|
|
offset = replace_variables(offset)
|
|
obj = the_object_name_exists(name)
|
|
props = tool.Blender.get_object_bim_props(obj)
|
|
assert props.blender_offset_type == "CARTESIAN_POINT"
|
|
obj_offset = np.array(tuple(map(float, props.cartesian_point_offset.split(","))))
|
|
offset = np.array(tuple(map(float, offset.split(","))))
|
|
assert np.allclose(obj_offset, offset)
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has the material "{material}"'))
|
|
def the_object_name_has_the_material_material(name: str, material: str) -> None:
|
|
assert material in [ms.material.name for ms in the_object_name_exists(name).material_slots if ms.material]
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has the IFC material "{material_name}"'))
|
|
def the_object_name_has_the_ifc_material_material_name(name: str, material_name: str):
|
|
element = tool.Ifc.get_entity(the_object_name_exists(name))
|
|
material = ifcopenshell.util.element.get_material(element)
|
|
assert material and material.Name == material_name
|
|
|
|
|
|
@then(
|
|
parsers.parse(
|
|
'the object "{name}" has a "{thickness}" thick layered material containing the material "{material_name}"'
|
|
)
|
|
)
|
|
def the_object_name_has_a_thickness_thick_layered_material_containing_the_material_material(
|
|
name, thickness, material_name
|
|
):
|
|
element = tool.Ifc.get_entity(the_object_name_exists(name))
|
|
material = ifcopenshell.util.element.get_material(element)
|
|
assert material and "LayerSet" in material.is_a()
|
|
if material.is_a("IfcMaterialLayerSetUsage"):
|
|
material = material.ForLayerSet
|
|
total_thickness = 0
|
|
material_names = []
|
|
for layer in material.MaterialLayers or []:
|
|
total_thickness += layer.LayerThickness
|
|
material_names.append(layer.Material.Name)
|
|
assert is_x(total_thickness, float(thickness))
|
|
assert material_name in material_names
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has no IFC materials'))
|
|
def the_object_has_no_ifc_materials(name: str) -> None:
|
|
element = tool.Ifc.get_entity(the_object_name_exists(name))
|
|
material = ifcopenshell.util.element.get_material(element)
|
|
assert material is None
|
|
|
|
|
|
@then(
|
|
parsers.parse(
|
|
'the object "{name}" has a profiled material containing the material "{material_name}" and profile "{profile_name}"'
|
|
)
|
|
)
|
|
def the_object_name_has_a_profiled_material_containing_the_material_material_and_profile_profile(
|
|
name, material_name, profile_name
|
|
):
|
|
element = tool.Ifc.get_entity(the_object_name_exists(name))
|
|
material = ifcopenshell.util.element.get_material(element)
|
|
assert material and "ProfileSet" in material.is_a()
|
|
if material.is_a("IfcMaterialProfileSetUsage"):
|
|
material = material.ForProfileSet
|
|
material_names = []
|
|
profile_names = []
|
|
for profile in material.MaterialProfiles or []:
|
|
material_names.append(profile.Material.Name)
|
|
profile_names.append(profile.Profile.ProfileName)
|
|
assert material_name in material_names, f"No material {material_name} found in profiled materials: {material_names}"
|
|
assert profile_name in profile_names, f"No profile {profile_name} found in material profiles: {profile_names}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" does not have the material "{material}"'))
|
|
def the_object_name_does_not_have_the_material_material(name, material):
|
|
assert material not in [ms.material.name for ms in the_object_name_exists(name).material_slots]
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is in the collection "{collection}"'))
|
|
def the_object_name_is_in_the_collection_collection(name, collection):
|
|
assert collection in [c.name for c in the_object_name_exists(name).users_collection]
|
|
|
|
|
|
@then(parsers.parse('the collection "{name1}" is in the collection "{name2}"'))
|
|
def the_collection_name1_is_in_the_collection_name2(name1, name2):
|
|
assert bpy.data.collections.get(name2).children.get(name1)
|
|
|
|
|
|
@then(parsers.parse('the collection "{name}" does not exist'))
|
|
def the_collection_name_does_not_exist(name):
|
|
obj = bpy.data.collections.get(name)
|
|
assert obj is None, f"Collection {name} exists"
|
|
|
|
|
|
@then(parsers.parse('objects starting with "{name}" do not exist'))
|
|
def objects_not_exist_starting_with(name):
|
|
objs = [obj for obj in bpy.data.objects if obj.name.startswith(name) and len(obj.users_collection) > 0]
|
|
if len(objs) > 0:
|
|
assert False, f'{len(objs)} objects starting with "{name}" exist'
|
|
assert True
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is at "{location}"'))
|
|
def the_object_name_is_at_location(name, location):
|
|
obj_location = the_object_name_exists(name).location
|
|
assert (
|
|
obj_location - Vector([float(co) for co in location.split(",")])
|
|
).length < 0.05, f"Object is at {obj_location} instead of {location}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has a vertex at "{location}"'))
|
|
def the_object_name_has_a_vertex_at_location(name, location):
|
|
obj = the_object_name_exists(name)
|
|
is_pass = False
|
|
target = Vector([float(co) for co in location.split(",")])
|
|
verts = []
|
|
depsgraph = bpy.context.evaluated_depsgraph_get()
|
|
obj_eval = obj.evaluated_get(depsgraph)
|
|
mesh = obj_eval.to_mesh(preserve_all_data_layers=False, depsgraph=depsgraph)
|
|
try:
|
|
for inst in depsgraph.object_instances:
|
|
if inst.object.original is obj:
|
|
mw = inst.matrix_world
|
|
for i, v in enumerate(mesh.vertices):
|
|
verts.append(mw @ v.co)
|
|
if (verts[-1] - target).length < 0.001:
|
|
is_pass = True
|
|
finally:
|
|
obj_eval.to_mesh_clear()
|
|
assert is_pass, f"No verts found at {location}: {verts}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has no scale'))
|
|
def the_object_name_has_no_scale(name):
|
|
assert the_object_name_exists(name).scale == Vector(
|
|
(
|
|
1.0,
|
|
1.0,
|
|
1.0,
|
|
)
|
|
)
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" dimensions are "{dimensions}"'))
|
|
def the_object_name_dimensions_are_dimensions(name, dimensions):
|
|
actual_dimensions = list(the_object_name_exists(name).dimensions)
|
|
expected_dimensions = [float(co) for co in dimensions.split(",")]
|
|
for i, number in enumerate(actual_dimensions):
|
|
assert is_x(number, expected_dimensions[i]), f"Expected {expected_dimensions} but got {actual_dimensions}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" top right corner is at "{location}"'))
|
|
def the_object_name_top_right_corner_is_at_location(name, location):
|
|
obj = the_object_name_exists(name)
|
|
obj_corner = obj.matrix_world @ Vector(obj.bound_box[6])
|
|
assert (
|
|
obj_corner - Vector([float(co) for co in location.split(",")])
|
|
).length < 0.05, f"Object has top right corner {obj_corner} instead of {location}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" bottom left corner is at "{location}"'))
|
|
def the_object_name_bottom_left_corner_is_at_location(name, location):
|
|
obj = the_object_name_exists(name)
|
|
obj_corner = obj.matrix_world @ Vector(obj.bound_box[0])
|
|
assert (
|
|
obj_corner - Vector([float(co) for co in location.split(",")])
|
|
).length < 0.05, f"Object has bottom left corner {obj_corner} instead of {location}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is contained in "{container_name}"'))
|
|
def the_object_name_is_contained_in_container_name(name, container_name):
|
|
ifc = an_ifc_file_exists()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
container = ifcopenshell.util.element.get_container(element)
|
|
if not container:
|
|
assert False, f'Object "{name}" is not in any container'
|
|
assert container.Name == container_name, f'Object "{name}" is in {container}'
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is contained in object "{container_name}"'))
|
|
def the_object_name_is_contained_in_object_container_name(name: str, container_name: str) -> None:
|
|
ifc = an_ifc_file_exists()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
container = ifcopenshell.util.element.get_container(element)
|
|
if not container:
|
|
assert False, f'Object "{name}" is not in any container'
|
|
container_obj = tool.Ifc.get_object(container)
|
|
assert container_obj.name == container_name, f'Object "{name}" is in {container_obj}'
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" is aggregated by object "{aggregate_name}"'))
|
|
def the_object_name_is_aggregated_by_object_aggregate_name(name: str, aggregate_name: str) -> None:
|
|
ifc = an_ifc_file_exists()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
aggregate = ifcopenshell.util.element.get_aggregate(element)
|
|
if not aggregate:
|
|
assert False, f'Object "{name}" is not aggregated by any element'
|
|
aggregate_obj = tool.Ifc.get_object(aggregate)
|
|
assert aggregate_obj.name == aggregate_name, f'Object "{name}" is aggregated by {aggregate_obj}'
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has no aggregate'))
|
|
def the_object_name_has_no_aggregate(name: str) -> None:
|
|
ifc = an_ifc_file_exists()
|
|
element = ifc.by_id(tool.Blender.get_ifc_definition_id(the_object_name_exists(name)))
|
|
aggregate = ifcopenshell.util.element.get_aggregate(element)
|
|
if aggregate:
|
|
assert False, f'Object "{name}" is aggregated by element "{aggregate}"'
|
|
|
|
|
|
@then(parsers.parse('the file "{name}" should contain "{value}"'))
|
|
def the_file_name_should_contain_value(name, value):
|
|
name = replace_variables(name)
|
|
with open(name, "r") as f:
|
|
content = f.read()
|
|
assert value in content, f"File {name} does not contain {value}:\n{content}"
|
|
|
|
|
|
@then(parsers.parse('the file "{name}" should not contain "{value}"'))
|
|
def the_file_name_should_not_contain_value(name, value):
|
|
name = replace_variables(name)
|
|
with open(name, "r") as f:
|
|
content = f.read()
|
|
assert value not in content, f"File {name} contains {value}:\n{content}"
|
|
|
|
|
|
@then(parsers.parse('the object "{name}" has no modifiers'))
|
|
def the_object_name_has_no_modifiers(name):
|
|
assert len(the_object_name_exists(name).modifiers) == 0
|
|
|
|
|
|
@given(parsers.parse('I load the IFC test file "{filepath}"'))
|
|
def i_load_the_ifc_test_file(filepath):
|
|
filepath = f"{variables['cwd']}{filepath}"
|
|
bpy.ops.bim.load_project(filepath=filepath)
|
|
|
|
|
|
@given("I load the demo construction library")
|
|
@when("I load the demo construction library")
|
|
def i_add_a_construction_library():
|
|
lib_path = "./bonsai/bim/data/libraries/IFC4 Demo Library.ifc"
|
|
bpy.ops.bim.select_library_file(filepath=lib_path, append_all=True)
|
|
|
|
|
|
@given(parsers.parse('the cursor is at "{location}"'))
|
|
@when(parsers.parse('the cursor is at "{location}"'))
|
|
def the_cursor_is_at_location(location):
|
|
bpy.context.scene.cursor.location = [float(co) for co in location.split(",")]
|
|
|
|
|
|
@given("I display the construction type browser")
|
|
@when("I display the construction type browser")
|
|
def i_display_the_construction_type_browser():
|
|
bpy.ops.bim.display_constr_types("INVOKE_DEFAULT")
|
|
|
|
|
|
@given("I add the construction type")
|
|
@when("I add the construction type")
|
|
def i_add_the_active_construction_type():
|
|
props = tool.Model.get_model_props()
|
|
bpy.ops.bim.add_occurrence(relating_type_id=int(props.relating_type_id))
|
|
|
|
|
|
@then(parsers.parse("construction type is {relating_type_name}"))
|
|
def construction_type(relating_type_name):
|
|
props = tool.Model.get_model_props()
|
|
relating_type = AuthoringData.relating_type_name_by_id(props.ifc_class, props.relating_type_id)
|
|
assert relating_type == relating_type_name, f"Construction Type is a {relating_type}, not a {relating_type_name}"
|
|
|
|
|
|
@given("I toggle edit mode")
|
|
@when("I toggle edit mode")
|
|
@then("I toggle edit mode")
|
|
def i_toggle_edit_mode():
|
|
props = tool.Geometry.get_geometry_props()
|
|
print(f"Toggling from {bpy.context.mode} / {props.mode} ...")
|
|
print("Selected items:", bpy.context.active_object, bpy.context.selected_objects)
|
|
if bpy.context.mode == "OBJECT":
|
|
bpy.ops.bim.override_mode_set_edit()
|
|
else:
|
|
bpy.ops.bim.override_mode_set_object()
|
|
print(f"... mode is now {bpy.context.mode} / {props.mode}")
|
|
|
|
|
|
@when("I move the cursor to the bottom left corner")
|
|
def move_cursor_bottom_left():
|
|
bpy.context.window.cursor_warp(10, 10)
|
|
|
|
|
|
@given(parsers.parse("I prepare to undo"))
|
|
@when(parsers.parse("I prepare to undo"))
|
|
@then(parsers.parse("I prepare to undo"))
|
|
def prepare_undo():
|
|
bpy.ops.ed.undo_push(message="UNDO STEP")
|
|
|
|
|
|
@given(parsers.parse("I undo"))
|
|
@when(parsers.parse("I undo"))
|
|
@then(parsers.parse("I undo"))
|
|
def hit_undo():
|
|
bpy.ops.ed.undo_push(message="UNDO STEP")
|
|
bpy.ops.ed.undo()
|
|
# override = tool.Blender.get_viewport_context()
|
|
# with bpy.context.temp_override(**override):
|
|
# bpy.ops.ed.undo()
|
|
|
|
|
|
@then(parsers.parse('the object "{obj_name1}" has a connection with "{obj_name2}"'))
|
|
def the_obj1_has_a_connection_with_obj2(obj_name1, obj_name2):
|
|
element1 = replace_variables(obj_name1)
|
|
element1 = tool.Ifc.get_entity(the_object_name_exists(element1))
|
|
element2 = replace_variables(obj_name2)
|
|
element2 = tool.Ifc.get_entity(the_object_name_exists(element2))
|
|
connections = []
|
|
if hasattr(element1, "ConnectedTo") and element1.ConnectedTo:
|
|
connections = [connection for connection in element1.ConnectedTo]
|
|
elif hasattr(element1, "ConnectedFrom") and element1.ConnectedFrom:
|
|
connections = [connection for connection in element1.ConnectedFrom]
|
|
else:
|
|
assert False, f'Object "{obj_name1}" has no connections'
|
|
|
|
relationships = {}
|
|
for conn in connections:
|
|
relationships[conn.RelatedElement] = conn.RelatingElement
|
|
|
|
for key, value in relationships.items():
|
|
assert (key.id() == element1.id() and value.id() == element2.id()) or (
|
|
key.id() == element2.id() and value.id() == element1.id()
|
|
), f"The object {obj_name1} is connected to {obj_name2}"
|
|
|
|
|
|
@then(parsers.parse('the object "{obj_name1}" and "{obj_name2}" belong to the same Linked Aggregate Group'))
|
|
def the_obj1_and_obj2_belong_the_same_linked_aggregate_group(obj_name1, obj_name2):
|
|
element1 = replace_variables(obj_name1)
|
|
element1 = tool.Ifc.get_entity(the_object_name_exists(element1))
|
|
element2 = replace_variables(obj_name2)
|
|
element2 = tool.Ifc.get_entity(the_object_name_exists(element2))
|
|
|
|
elements = [element1, element2]
|
|
groups = []
|
|
for element in elements:
|
|
product_linked_agg_group = [
|
|
r.RelatingGroup
|
|
for r in getattr(element, "HasAssignments", []) or []
|
|
if r.is_a("IfcRelAssignsToGroup")
|
|
if "BBIM_Linked_Aggregate" in r.RelatingGroup.Name
|
|
]
|
|
try:
|
|
groups.append(product_linked_agg_group[0].id())
|
|
except:
|
|
assert False, "Object is not part of a Linked Aggregate."
|
|
|
|
assert groups[0] == groups[1], "Objects do not belong to the same Linked Aggregate group"
|
|
|
|
|
|
@when(parsers.parse('the object layer length is set to "{value}"'))
|
|
def the_obj_layer_length_is_set_to(value):
|
|
value = float(value)
|
|
try:
|
|
eval("bpy.context.scene.BIMModelProperties.length")
|
|
except:
|
|
assert False, f"Property BIMModelProperties.length does not exist when trying to set to value {value}"
|
|
props = tool.Model.get_model_props()
|
|
props.length = value
|
|
bpy.ops.bim.change_layer_length(length=value)
|
|
|
|
|
|
# These definitions are not to be used in tests but simply in debugging failing tests
|
|
|
|
|
|
@given(parsers.parse("I run test code"))
|
|
@when(parsers.parse("I run test code"))
|
|
@then(parsers.parse("I run test code"))
|
|
def run_test_code():
|
|
pass
|
|
|
|
|
|
@given(parsers.parse("I fail"))
|
|
@when(parsers.parse("I fail"))
|
|
@then(parsers.parse("I fail"))
|
|
def i_fail():
|
|
assert False
|
|
|
|
|
|
@given(parsers.parse("I save sample test files"))
|
|
@when(parsers.parse("I save sample test files"))
|
|
@then(parsers.parse("I save sample test files"))
|
|
def saving_sample_test_files() -> None:
|
|
filepath = TMP / "sample_test_file"
|
|
print(f"Saved to {filepath}")
|
|
bpy.ops.bim.save_project(filepath=filepath.with_suffix(".ifc").__str__(), should_save_as=True)
|
|
bpy.ops.wm.save_as_mainfile(filepath=filepath.with_suffix(".blend").__str__())
|
|
|
|
|
|
@given(parsers.parse("I load test blend file"))
|
|
@when(parsers.parse("I load test blend file"))
|
|
@then(parsers.parse("I load test blend file"))
|
|
def opening_sample_test_files_in_blender():
|
|
filepath = TMP / "sample_test_file.blend"
|
|
bpy.ops.wm.open_mainfile(filepath=filepath.__str__(), display_file_selector=False)
|
|
|
|
|
|
# TODO: merge to single fixture with `saving_sample_test_files`; add "and wait"
|
|
@given(parsers.parse("I save sample test files and open in blender"))
|
|
@when(parsers.parse("I save sample test files and open in blender"))
|
|
@then(parsers.parse("I save sample test files and open in blender"))
|
|
def saving_sample_test_files_and_open_in_blender():
|
|
saving_sample_test_files()
|
|
filepath = f"{variables['cwd']}/test/files/temp/sample_test_file.blend"
|
|
import subprocess
|
|
|
|
subprocess.Popen([bpy.app.binary_path, f"{filepath}"])
|
|
|
|
|
|
@given(parsers.parse("I run pdb"))
|
|
@when(parsers.parse("I run pdb"))
|
|
@then(parsers.parse("I run pdb"))
|
|
def run_pdb():
|
|
import pdb
|
|
|
|
pdb.set_trace()
|
|
|
|
|
|
@given(parsers.parse("I start debugpy"))
|
|
@when(parsers.parse("I start debugpy"))
|
|
@then(parsers.parse("I start debugpy"))
|
|
def run_debugpy() -> types.NoneType:
|
|
import debugpy
|
|
|
|
debugpy.listen(5678)
|
|
debugpy.wait_for_client()
|
|
|
|
# Set a breakpoint here.
|
|
print("debugpy connected")
|