diff --git a/.github/workflows/build-windows.yml b/.github/workflows/build-windows.yml index dff9f30..a2d481f 100644 --- a/.github/workflows/build-windows.yml +++ b/.github/workflows/build-windows.yml @@ -35,7 +35,7 @@ jobs: git clone https://github.com/abhishekvraman/Propylean.git cd Propylean python -m build - python -m pip install dist/propylean-0.2.5-py3-none-any.whl + python -m pip install dist/propylean-0.2.6-py3-none-any.whl - name: Lint with flake8 run: | # stop the build if there are Python syntax errors or undefined names diff --git a/LICENSE b/LICENSE index 1969c3e..6a15c42 100644 --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ -Copyright (c) 2023, 2022, 2021 Abhishek Venkitta Raman +Copyright (c)2024, 2023, 2022, 2021 Abhishek Venkitta Raman Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/Models/LPG_bullet_analysis.ipynb b/Models/LPG_bullet_analysis.ipynb index d39e2a5..5736a73 100644 --- a/Models/LPG_bullet_analysis.ipynb +++ b/Models/LPG_bullet_analysis.ipynb @@ -209,17 +209,29 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "" ] }, + "execution_count": 13, "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -228,23 +240,23 @@ "import matplotlib.pyplot as plt\n", "\n", "plt.figure(figsize=(18, 6), dpi=80)\n", - "# Plot\n", - "lpg_1.liquid_level.plot()\n", + "\n", "\n", "# Labelling \n", "plt.ylabel(\"Liquid-level (m)\") \n", "plt.xlabel(\"Time (s)\")\n", "plt.title(\"Liquid level in Bullet \" + lpg_1.tag)\n", "\n", - "# # Set plot limits.\n", + "# Set plot limits.\n", "plt.ylim(0, lpg_1.ID.value)\n", "plt.axhline(y=lpg_1.HHLL.value, color='r', linestyle='--', )\n", "plt.axhline(y=lpg_1.LLLL.value, color='r', linestyle='--', )\n", "plt.axhline(y=lpg_1.HLL.value, color='y', linestyle='--', )\n", "plt.axhline(y=lpg_1.LLL.value, color='y', linestyle='--', )\n", "\n", - "# # Display\n", - "plt.show()" + "\n", + "# Plot\n", + "lpg_1.liquid_level.plot()" ] }, { @@ -254,12 +266,14 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -279,12 +293,14 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -310,12 +326,14 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -346,7 +364,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -360,7 +378,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.1" + "version": "3.10.0" }, "vscode": { "interpreter": { diff --git a/Models/pump_circuit.ipynb b/Models/pump_circuit.ipynb index 7c6d8ee..1e0d49c 100644 --- a/Models/pump_circuit.ipynb +++ b/Models/pump_circuit.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "id": "c98d186c", "metadata": {}, @@ -32,12 +33,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Material Stream Tag: Water 0\n", - "Material Stream Tag: Water 1\n", - "Material Stream Tag: Water 2\n", - "Material Stream Tag: Water 3\n", - "Material Stream Tag: Water 4\n", - "Material Stream Tag: Water 5\n" + "Material Stream with tag: Water 0\n", + "Material Stream with tag: Water 1\n", + "Material Stream with tag: Water 2\n", + "Material Stream with tag: Water 3\n", + "Material Stream with tag: Water 4\n", + "Material Stream with tag: Water 5\n" ] } ], @@ -118,6 +119,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "098cf610", "metadata": {}, @@ -150,6 +152,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "01428f74", "metadata": {}, @@ -180,6 +183,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "6223f571", "metadata": {}, @@ -264,6 +268,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "6e55a763", "metadata": {}, @@ -294,6 +299,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "a2f94a64", "metadata": {}, @@ -346,6 +352,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "68626db0", "metadata": {}, @@ -376,6 +383,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "cbcc786e", "metadata": {}, @@ -434,6 +442,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "080702ed", "metadata": {}, @@ -464,6 +473,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "eedc8eb9", "metadata": {}, @@ -514,6 +524,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "242284cc", "metadata": {}, @@ -553,7 +564,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\VijayaShree\\Documents\\Abhishek\\Propylean\\src\\propylean\\properties.py:87: UserWarning: Time series of the property is not set. Series attribute is considerd using 'value', 'max_val', or 'min_val' if provided.\n", + "C:\\Users\\AVRaman\\Documents\\Codes\\Propylean\\src\\propylean\\properties.py:89: UserWarning: Time series of the property is not set. Series attribute is considerd using 'value', 'max_val', or 'min_val' if provided.\n", " warn(\"Time series of the property is not set. Series attribute is considerd using 'value', 'max_val', or 'min_val' if provided.\")\n" ] }, @@ -575,7 +586,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -589,7 +600,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.1" + "version": "3.10.0" }, "vscode": { "interpreter": { diff --git a/project_resources/ProcessInstrumentationandControlSystem.ppt b/project_resources/ProcessInstrumentationandControlSystem.ppt new file mode 100644 index 0000000..7c00894 Binary files /dev/null and b/project_resources/ProcessInstrumentationandControlSystem.ppt differ diff --git a/project_resources/rd-te-r06202-008.pdf b/project_resources/rd-te-r06202-008.pdf new file mode 100644 index 0000000..a7e861b Binary files /dev/null and b/project_resources/rd-te-r06202-008.pdf differ diff --git a/setup.cfg b/setup.cfg index 7fa17b1..497e94f 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,6 +1,6 @@ [metadata] name = propylean -version = 0.2.5 +version = 0.2.6 author = Abhishek V Raman author_email = description = The open-source calculations and analytics package for chemical process industries. diff --git a/src/propylean/equipments/abstract_equipment_classes.py b/src/propylean/equipments/abstract_equipment_classes.py index e2cd4c7..b82bbbf 100644 --- a/src/propylean/equipments/abstract_equipment_classes.py +++ b/src/propylean/equipments/abstract_equipment_classes.py @@ -24,16 +24,8 @@ def __init__(self, **inputs) -> None: Type: str Acceptable values: Any string type Default value: None - Description: Equipment tag the user wants to provide. If not provided, then tag is automatically generated - - dynamic_state: - Required: No - Type: bool - Acceptable values: True or False - Default value: False - Description: If equipment is in dynamic state and inventory is changing. - TODO: Provide dynamic simulation capabilities. - + Description: Equipment tag the user wants to provide. If not provided, then tag is automatically generated. + pressure_drop: Required: No Type: int or float (recommended) @@ -54,15 +46,12 @@ def __init__(self, **inputs) -> None: >>> class NewEquipment(_EquipmentOneInletOutlet): ...... """ - if 'tag' not in inputs: - self.tag = self._create_equipment_tag() - else: - self.tag = inputs['tag'] - self.dynamic_state = False if 'dynamic_state' not in inputs else False + self.tag = inputs.pop('tag', self._create_equipment_tag()) #Flow properties self._inlet_mass_flowrate = prop.MassFlowRate() self._outlet_mass_flowrate = prop.MassFlowRate() + self._inventory_change_rate = prop.MassFlowRate() self.design_flowrate = prop.MassFlowRate() #Pressure properties @@ -280,13 +269,10 @@ def outlet_mass_flowrate(self, value): @property def inventory_change_rate(self): self = self._get_equipment_object(self) - if not self.dynamic_state: - return prop.MassFlowRate(0, self.inlet_mass_flowrate.unit) - return self._inlet_mass_flowrate - self._outlet_mass_flowrate + return self._inventory_change_rate @inventory_change_rate.setter def inventory_change_rate(self, value): - raise Exception("Dynamic process is not yet supported.") - _Validators.validate_arg_prop_value_type("inventory_change_rate", value, (int)) + _Validators.validate_arg_prop_value_type("inventory_change_rate", value, (int, float, prop.MassFlowRate)) self = self._get_equipment_object(self) value, unit = self._tuple_property_value_unit_returner(value, prop.MassFlowRate) if unit is None: diff --git a/src/propylean/instruments/measurement.py b/src/propylean/instruments/measurement.py index 68c963b..edd5b34 100644 --- a/src/propylean/instruments/measurement.py +++ b/src/propylean/instruments/measurement.py @@ -1,6 +1,255 @@ from propylean.equipments.generic_equipment_classes import _EquipmentOneInletOutlet +from propylean.validators import _Validators +from propylean.properties import _Property, Pressure, Temperature, VolumetricFlowRate +from propylean.series import Series -class FlowMeter(_EquipmentOneInletOutlet): +# Base class for all instruments that measures (makes observations). +# Classes derived from this act as data store. +class _MeasuringInstruments(object): + items = [] + def __init__(self, measured_property, measured_unit, **inputs) -> None: + """ + DESCRIPTION: + Parent class for all instruments having primary task to + measure properties as observations which could be stored in + a databases. + + PARAMETERS: + measured_property: + Required: Yes + Type: propylean.property + Acceptable values: All properties that can be measured. + Default value: NA + Description: Property class that the instrument measures. + + measured_unit: + Required: Yes + Type: string + Acceptable values: All units associated with measured_property. + Default value: NA + Description: Unit that the instrument measures for the measured_property. + + tag: + Required: No + Type: str + Acceptable values: Any string type + Default value: None + Description: Instrument tag the user wants to provide. If not provided, then tag is automatically generated. + + i_range: + Required: No + Type: tuple + Acceptable values: Tuple with two elements. + First element representing minimum measured and second element + representing the maximum value instrument can measure. + Both are inclusive. + Default value: NA + Description: Specifies the Range of the instrument. That is minimum to maximum + values that can be measured. + + resolution: + Required: No + Type: float or int + Acceptable values: All positive values. + Default value: NA + Description: Specifies the Resolution of the instrument. + + RETURN VALUE: + Type: _MeasuringInstruments + Description: + + ERROR RAISED: + Type: + Description: + + SAMPLE USE CASES: + >>> class AwesomeMesuringDevice(_MeasuringInstruments): + >>> def __init__(**kwargs): + >>> some_property = 20 + + """ + self._measured_property = measured_property + self.measured_unit = measured_unit + self._i_range = inputs.pop("i_range", None) + self._resolution = inputs.pop("resolution", None) + if self._resolution is not None: + self.resolution = self._resolution + self._observations = None + self.tag = inputs.pop("tag", self._create_instrument_tag()) + + def _get_instrument_index(cls, tag): + for index, instrument in enumerate(cls.items): + if instrument.tag == tag: + return index + return None + + @classmethod + def _get_instrument_object(cls, obj): + try: + return cls.items[obj.index] + except IndexError: + raise Exception("Instrument does not exist!") + except AttributeError: + return obj + + @classmethod + def _update_instrument_object(cls, obj): + _Validators.validate_arg_prop_value_type("obj", obj, cls) + try: + cls.items[obj.index] = obj + except: + pass + + @property + def index(self): + return self._index + + @property + def tag(self): + return self._tag + @tag.setter + def tag(self, value): + _Validators.validate_arg_prop_value_type("tag", value, (str)) + if self._check_tag_assigned(value): + msg = "Tag '{}' already assigned!".format(value) + raise Exception(msg) + else: + self._tag = value + + def _create_instrument_tag(cls): + i = 1 + class_name = type(cls).__name__ + tag = class_name+ "_" + str(i) + while cls._check_tag_assigned(tag): + tag = class_name+ "_" + str(i) + i += 1 + return tag + def _check_tag_assigned(cls, tag): + for instru in cls.items: + if tag == instru.tag: + return True + return False + + @property + def measured_property(self): + self = self._get_instrument_object(self) + return self._measured_property + @measured_property.setter + def measured_property(self, value): + _Validators.validate_child_class("measured_property", + value, + _Property, + "propylean.property") + self = self._get_instrument_object(self) + self._measured_property = value + self._update_instrument_object(self) + + @property + def measured_unit(self): + self = self._get_instrument_object(self) + return self._measured_unit + @measured_unit.setter + def measured_unit(self, value): + #Need to get list of units based on measured_property and validate. + self = self._get_instrument_object(self) + _Validators.validate_arg_prop_value_type(arg_prop_name="measured_unit", + value=value, + correct_types=str) + # Validate the unit. + self.measured_property(unit=value) + + self._measured_unit = value + self._update_instrument_object(self) + + @property + def i_range(self): + self = self._get_instrument_object(self) + return self._i_range + @i_range.setter + def i_range(self, value): + _Validators.validate_arg_prop_value_type("i_range", value, tuple) + self = self._get_instrument_object(self) + self._i_range = value + self._update_instrument_object(self) + + @property + def resolution(self): + self = self._get_instrument_object(self) + return self._resolution + @resolution.setter + def resolution(self, value): + _Validators.validate_arg_prop_value_type("resolution", value, (int, float)) + _Validators.validate_positive_value("resolution", value) + self = self._get_instrument_object(self) + self._resolution = value + self._update_instrument_object(self) + + @property + def observations(self): + self = self._get_instrument_object(self) + return self._observations + @observations.setter + def observations(self, value): + _Validators.validate_arg_prop_value_type("observations", value, Series) + self._observations = value + self._update_instrument_object(self) + + def __eq__(self, other): + if isinstance(other, type(self)): + return self.tag == other.tag + else: + return False + + +class PressureGuage(_MeasuringInstruments): + items = [] + def __init__(self, measured_unit="Pa", **inputs) -> None: + super().__init__(measured_property=Pressure, measured_unit=measured_unit, **inputs) + self._index = len(PressureGuage.items) + PressureGuage.items.append(self) + + def __repr__(self): + self = self._get_instrument_object(self) + return "PressureGuage with tag: " + self.tag + def __hash__(self): + return hash(self.__repr__()) + + @classmethod + def list_objects(cls): + return cls.items + + @_MeasuringInstruments.measured_property.setter + def measured_property(self, value): + raise Exception("Cannot set measured_property of PressureGuage") + + +class TemperatureGuage(_MeasuringInstruments): + items = [] + def __init__(self, measured_unit="C", **inputs) -> None: + super().__init__(measured_property=Temperature, measured_unit=measured_unit, **inputs) + self._index = len(TemperatureGuage.items) + TemperatureGuage.items.append(self) + + def __repr__(self): + self = self._get_instrument_object(self) + return "TemperatureGuage with tag: " + self.tag + def __hash__(self): + return hash(self.__repr__()) + + @classmethod + def list_objects(cls): + return cls.items + + @_MeasuringInstruments.measured_property.setter + def measured_property(self, value): + raise Exception("Cannot set measured_property of TemperatureGuage") + +class FlowMeter(_EquipmentOneInletOutlet): + """ + Eventhough Flow meter is an instrument, it kind of acts like an + inline equipment as it shares properties and is connected to equipments(pipes) + on both inlet and outlet. + """ items = [] def __init__(self, **inputs) -> None: super().__init__( **inputs) @@ -10,11 +259,11 @@ def __init__(self, **inputs) -> None: FlowMeter.items.append(self) def __repr__(self): - self = self._get_equipment_object(self) + self = self._get_equipment_object(self) return "Flow Meter with tag: " + self.tag def __hash__(self): return hash(self.__repr__()) @classmethod def list_objects(cls): - return cls.items + return cls.items \ No newline at end of file diff --git a/src/propylean/properties.py b/src/propylean/properties.py index dac820a..eaa9a13 100644 --- a/src/propylean/properties.py +++ b/src/propylean/properties.py @@ -1,25 +1,23 @@ -from pandas import Series, DataFrame from propylean.validators import _Validators from propylean.constants import ConversionFactors from warnings import warn class _Property(object): - def __init__(self, value=None, unit=None, time_series=None, min_val=None, max_val=None): + def __init__(self, value=None, unit=None, min_val=None, max_val=None): _Validators.validate_arg_prop_value_type("value", value, (int, float)) _Validators.validate_arg_prop_value_type("unit", unit, str) - _Validators.validate_arg_prop_value_type("time_series", time_series, - (Series, DataFrame, dict)) self._value = value self._min_val = min_val self._max_val = max_val self._unit = unit - self._time_series = time_series + def __eq__(self, other): if (isinstance(other, _Property) and self.value == other.value and self.unit == other.unit): return True return False + @property def value(self): return self._value @@ -51,43 +49,6 @@ def unit(self): def unit(self, unit): _Validators.validate_arg_prop_value_type("unit", unit, (str)) self._unit = unit - - @property - def time_series(self): - return self._time_series - @time_series.setter - def time_series(self, time_series): - _Validators.validate_arg_prop_value_type("time_series", time_series, - (Series, DataFrame, dict)) - - if isinstance(time_series, dict): - time_series = Series(data=time_series, index=list(time_series.keys())) - elif isinstance(time_series, DataFrame): - if len(time_series.columns) == 2: - time_index = time_series[time_series.columns[0]] - data = time_series[time_series.columns[1]] - time_series = DataFrame(data=list(data), index=time_index) - - if len(time_series.columns) == 1: - time_series = time_series[time_series.columns[0]] - else: - raise Exception("""Incorrect number of columns provided in DataFrame. - Should be either one with index as time-series or two with first column as time-series and second as property data.""") - - self._time_series = time_series - - def __getattr__(self, name): - if not name.startswith("_") and self.time_series is None: - time_series = {0: self.value} - if self.min_val is not None: - time_series[1] = self.min_val - if self.max_val is not None: - time_series[2] = self.max_val - time_series = Series(data=time_series, index=list(time_series.keys())) - warn("Time series of the property is not set. Series attribute is considerd using 'value', 'max_val', or 'min_val' if provided.") - else: - time_series = self.time_series - return getattr(time_series, name) def __repr__(self) -> str: return str(self.value) + ' ' + self.unit @@ -138,8 +99,8 @@ def _convert_values_for_unit_change(self, unit, invert_factor=False): self._unit = unit class Length(_Property): - def __init__(self, value=0, unit='m', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=0, unit='m', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter @@ -164,8 +125,8 @@ def unit(self, unit): raise class Time(_Property): - def __init__(self, value=0, unit='sec', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=0, unit='sec', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter @@ -189,8 +150,8 @@ def unit(self, unit): raise class Pressure(_Property): - def __init__(self, value=101325, unit='Pa', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=101325, unit='Pa', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter @@ -219,8 +180,8 @@ def unit(self, unit): raise class Temperature(_Property): - def __init__(self, value=298, unit='K', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=298, unit='K', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter @@ -278,8 +239,8 @@ def __sub__(self, other): return subtraction class MassFlowRate(_Property): - def __init__(self, value=0, unit='kg/s', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=0, unit='kg/s', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter @@ -310,8 +271,8 @@ def __add__(self, other): return super().__add__(other) class Mass(_Property): - def __init__(self, value=0, unit='kg', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=0, unit='kg', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter @@ -335,8 +296,8 @@ def __add__(self, other): return super().__add__(other) class MolecularWeigth(_Property): - def __init__(self, value=0, unit='g/mol', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=0, unit='g/mol', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter def unit(self, unit): @@ -354,8 +315,8 @@ def unit(self, unit): raise class MolarFlowRate(_Property): - def __init__(self, value=1, unit='mol/s', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=1, unit='mol/s', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter @@ -381,8 +342,8 @@ def unit(self, unit): raise class VolumetricFlowRate(_Property): - def __init__(self, value = 1, unit='m^3/s', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value = 1, unit='m^3/s', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter def unit(self, unit): @@ -415,8 +376,8 @@ def unit(self, unit): raise class Volume(_Property): - def __init__(self, value = 0, unit= 'm^3', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value = 0, unit= 'm^3', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter def unit(self, unit): @@ -437,8 +398,8 @@ def unit(self, unit): raise class Density(_Property): - def __init__(self, value = 0, unit= 'kg/m^3', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value = 0, unit= 'kg/m^3', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter def unit(self, unit): @@ -457,8 +418,8 @@ def unit(self, unit): raise class DViscosity(_Property): - def __init__(self, value = 0, unit= 'Pa-s', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value = 0, unit= 'Pa-s', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter def unit(self, unit): @@ -477,8 +438,8 @@ def unit(self, unit): raise class Power(_Property): - def __init__(self, value = 0, unit= 'W', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value = 0, unit= 'W', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter @@ -516,8 +477,8 @@ def unit(self, unit): raise class Frequency(_Property): - def __init__(self, value=0, unit='Hz', time_series=None, min_val=None, max_val=None): - super().__init__(value, unit, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=0, unit='Hz', min_val=None, max_val=None): + super().__init__(value, unit, max_val=max_val, min_val=min_val) self.unit = unit @_Property.unit.setter def unit(self, unit): @@ -548,8 +509,8 @@ def __eq__(self, other): return False class Dimensionless(_Property): - def __init__(self, value=None, name=None, time_series=None, min_val=None, max_val=None): - super().__init__(value=value, unit=None, time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=None, name=None, min_val=None, max_val=None): + super().__init__(value=value, unit=None, max_val=max_val, min_val=min_val) self._name = name @property @@ -570,8 +531,8 @@ def __repr__(self) -> str: return "{} with value {}".format(self.name, self.value) class Efficiency(Dimensionless): - def __init__(self, value=1, time_series=None, min_val=0, max_val=1): - super().__init__(value=value, name="Efficiency", time_series=time_series, max_val=max_val, min_val=min_val) + def __init__(self, value=1, min_val=0, max_val=1): + super().__init__(value=value, name="Efficiency", max_val=max_val, min_val=min_val) if value < 0 or min_val < 0 or max_val < 0: raise Exception("Provide a non-negative value for efficiency.") else: diff --git a/src/propylean/series.py b/src/propylean/series.py new file mode 100644 index 0000000..a7630d4 --- /dev/null +++ b/src/propylean/series.py @@ -0,0 +1,64 @@ +from pandas import Series as PdSeries +from propylean.validators import _Validators +from propylean.properties import _Property + +class Series(PdSeries): + def __init__(self, data, prop, unit=None, index=None, + dtype=None, name=None, copy=False, fastpath=False) -> None: + """ + DESCRIPTION: + Class which wraps Pandas and PySpark Series. + + PARAMETERS: + data: + Required: Yes + Type: pandas.Series or pyspark.Series or array-like, dict, or scalar value + Acceptable values: Float or int in data structure mentioned in type + Default value: NA + Description: The data for the series that forms a time series. + + prop: + Required: Yes + Type: propylean.property + Acceptable values: All properties that can be measured. + Default value: NA + Description: Property class for the series data. + + unit: + Required: No + Type: string + Acceptable values: All units associated with property specified in 'prop'. + Default value: NA + Description: Unit that the property of the series has. If not specified, default unit of + the property is considered. + + + RETURN VALUE: + Type: Series + Description: + + ERROR RAISED: + Type: + Description: + + SAMPLE USE CASES: + >>> class AwesomeMesuringDevice(_MeasuringInstruments): + >>> def __init__(**kwargs): + >>> some_property = 20 + + """ + super().__init__(data=data, index=index, dtype=dtype, + name=name, copy=copy, fastpath=fastpath) + self._prop = None + self._unit = None + self.prop = prop + self.unit = unit + + @property + def prop(self): + return self._prop + @prop.setter + def prop(self, value): + _Validators.validate_child_class("prop", value, _Property, "physical or dimensionless property from propylean.properties") + self._prop = value + \ No newline at end of file diff --git a/src/propylean/streams.py b/src/propylean/streams.py index f4213dd..9db2ac3 100644 --- a/src/propylean/streams.py +++ b/src/propylean/streams.py @@ -19,7 +19,7 @@ def tag(self, value): self = self._get_stream_object(self) if value is None: value = self._create_stream_tag() - if self._check_tag_assigned(value): + elif self._check_tag_assigned(value): raise Exception("Tag already assinged!") self._tag = value self._update_stream_object(self) diff --git a/src/propylean/validators.py b/src/propylean/validators.py index f551d82..4dc23d4 100644 --- a/src/propylean/validators.py +++ b/src/propylean/validators.py @@ -22,11 +22,13 @@ def validate_arg_prop_value_type(cls, arg_prop_name, value, correct_types): if value is not None and not isinstance(value, correct_types): if isinstance(correct_types, tuple): correct_types = tuple(c_type.__name__ for c_type in correct_types) + errmsg = "Can be any one from" else: correct_types = correct_types.__name__ + errmsg = "Should be" - raise Exception("Incorrect type '{0}' provided to '{1}'. Should be '{2}'."\ - .format(value.__class__.__name__, arg_prop_name, correct_types)) + raise Exception("Incorrect type '{0}' provided to '{1}'. {2} '{3}'."\ + .format(value.__class__.__name__, arg_prop_name, errmsg, correct_types)) return True @classmethod @@ -52,8 +54,9 @@ def validate_arg_prop_value_list(cls, arg_prop_name, value, correct_values): if isinstance(value, str): value = value.lower() if value not in correct_values: - raise Exception("""Incorrect value '{0}' provided to '{1}'. Should be among '{2}'. - """.format(str(value), arg_prop_name, str(correct_values))) + errmsg = "Can be any one from" if len(correct_values) > 1 else "Should be" + raise Exception("""Incorrect value '{0}' provided to '{1}'. {2} '{3}'. + """.format(str(value), arg_prop_name, errmsg, str(correct_values))) return True @classmethod @@ -104,7 +107,7 @@ def validate_non_negative_value(self, arg_prop_name, value): """ DESCRIPTION: Function to validate values passed to properties or args is - non-negative. That is greater than Zero. + non-negative. That is greater than or equal to Zero. . PARAMETERS: arg_prop_name: @@ -121,6 +124,63 @@ def validate_non_negative_value(self, arg_prop_name, value): elif isinstance(value, tuple): value = value[0] if value < 0: + raise Exception("""Value passed to '{0}' should be greater than or equal to 0. + Value provided is {1}.""".format(arg_prop_name, value)) + return True + + @classmethod + def validate_positive_value(self, arg_prop_name, value): + """ + DESCRIPTION: + Function to validate values passed to properties or args is + Positive. That is greater than Zero. + . + PARAMETERS: + arg_prop_name: + Required: Yes + Type: String + Description: Name of the argument or property. + value: + Required: Yes + Type: Any + Description: Value of the argument or property. + """ + if not isinstance(value, (int, float, tuple)): + value = value.value + elif isinstance(value, tuple): + value = value[0] + if value <= 0: raise Exception("""Value passed to '{0}' should be greater than 0. Value provided is {1}.""".format(arg_prop_name, value)) - return True \ No newline at end of file + return True + + @classmethod + def validate_child_class(self, arg_prop_name, child_class, parent_class, class_type): + """ + DESCRIPTION: + Function to validate values passed by user is a child class + of parent class. + PARAMETERS: + arg_prop_name: + Required: Yes + Type: String + Description: Name of the argument or property. + child_class: + Required: Yes + Type: propylean class + Description: Final class passed by user as input. + parent_class: + Required: Yes + Type: propylean parent class + Description: Parent class which are not exposed to end user. + class_type: + Required: Yes + Type: String + Description: Type of parent class in language of chemical industry + Example: "vessel" for _Vessels class. + """ + if not isinstance(child_class, type): + raise Exception(f"Value of {arg_prop_name} should be a propylean class used to declare property or objects.") + + if not issubclass(child_class, parent_class): + raise Exception(f"Invalid type provided for '{arg_prop_name}'. Should be a class of type {class_type}.") \ No newline at end of file diff --git a/tests/test_equipments/test_AirCooler.py b/tests/test_equipments/test_AirCooler.py index fd4393d..c5ee576 100644 --- a/tests/test_equipments/test_AirCooler.py +++ b/tests/test_equipments/test_AirCooler.py @@ -305,7 +305,7 @@ def test_AirCooler_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -313,7 +313,7 @@ def test_AirCooler_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -321,7 +321,7 @@ def test_AirCooler_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -329,7 +329,7 @@ def test_AirCooler_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -337,7 +337,7 @@ def test_AirCooler_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -345,7 +345,7 @@ def test_AirCooler_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -353,7 +353,7 @@ def test_AirCooler_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -361,7 +361,7 @@ def test_AirCooler_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -369,7 +369,7 @@ def test_AirCooler_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -377,7 +377,7 @@ def test_AirCooler_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -385,7 +385,7 @@ def test_AirCooler_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -393,7 +393,7 @@ def test_AirCooler_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -401,7 +401,7 @@ def test_AirCooler_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = AirCooler() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -412,7 +412,7 @@ def test_AirCooler_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_equipments/test_Bullet.py b/tests/test_equipments/test_Bullet.py index 3a258fc..fb71fd4 100644 --- a/tests/test_equipments/test_Bullet.py +++ b/tests/test_equipments/test_Bullet.py @@ -23,7 +23,7 @@ def test_Bullet_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -31,7 +31,7 @@ def test_Bullet_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -39,7 +39,7 @@ def test_Bullet_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -47,7 +47,7 @@ def test_Bullet_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -55,7 +55,7 @@ def test_Bullet_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -63,7 +63,7 @@ def test_Bullet_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -71,7 +71,7 @@ def test_Bullet_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -79,7 +79,7 @@ def test_Bullet_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -87,7 +87,7 @@ def test_Bullet_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -95,7 +95,7 @@ def test_Bullet_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -103,7 +103,7 @@ def test_Bullet_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -111,7 +111,7 @@ def test_Bullet_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -119,7 +119,7 @@ def test_Bullet_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -128,12 +128,12 @@ def test_Bullet_ID_incorrect_type_to_value(self): bullet = Bullet( ID=[4, "m"], length=(10, "m"), head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = Bullet() m4.ID = [] - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -142,12 +142,12 @@ def test_Bullet_length_incorrect_type_to_value(self): bullet = Bullet( ID=(4, "m"), length=[10, "m"], head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = Bullet() m4.length = [] - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -156,12 +156,12 @@ def test_Bullet_heayd_type_incorrect_type_to_value(self): bullet = Bullet( ID=(4, "m"), length=(10, "m"), head_type=["flat"]) - self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be 'str'", + self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be \'str\'", str(exp)) with pytest.raises(Exception) as exp: m4 = Bullet() m4.head_type = [] - self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be 'str'", + self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be \'str\'", str(exp)) @pytest.mark.negative @@ -169,7 +169,7 @@ def test_Bullet_LLLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.LLLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -177,7 +177,7 @@ def test_Bullet_LLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.LLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -185,7 +185,7 @@ def test_Bullet_NLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.NLL = [] - self.assertIn("Incorrect type 'list' provided to 'NLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'NLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -193,7 +193,7 @@ def test_Bullet_HLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.HLL = [] - self.assertIn("Incorrect type 'list' provided to 'HLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -201,7 +201,7 @@ def test_Bullet_HHLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.HHLL = [] - self.assertIn("Incorrect type 'list' provided to 'HHLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HHLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -209,7 +209,7 @@ def test_Bullet_operating_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.operating_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -217,7 +217,7 @@ def test_Bullet_operating_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Bullet() m4.operating_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -226,12 +226,12 @@ def test_Bullet_heayd_type_incorrect_value(self): Vertical_vessel = Bullet( ID=(4, "m"), length=(10, "m"), head_type="flatop") - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) with pytest.raises(Exception) as exp: m4 = Bullet() m4.head_type = "flatop" - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) @pytest.mark.negative @@ -243,7 +243,7 @@ def test_Bullet_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_equipments/test_CentrifugalCompressor.py b/tests/test_equipments/test_CentrifugalCompressor.py index d941b56..0e30895 100644 --- a/tests/test_equipments/test_CentrifugalCompressor.py +++ b/tests/test_equipments/test_CentrifugalCompressor.py @@ -360,7 +360,7 @@ def test_CentrifugalCompressor_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -368,7 +368,7 @@ def test_CentrifugalCompressor_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -376,7 +376,7 @@ def test_CentrifugalCompressor_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -384,7 +384,7 @@ def test_CentrifugalCompressor_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -392,7 +392,7 @@ def test_CentrifugalCompressor_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -400,7 +400,7 @@ def test_CentrifugalCompressor_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @@ -409,7 +409,7 @@ def test_CentrifugalCompressor_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -417,7 +417,7 @@ def test_CentrifugalCompressor_inlet_mass_flowrate_incorrect_type_to_value(self) with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -425,7 +425,7 @@ def test_CentrifugalCompressor_outlet_mass_flowrate_incorrect_type_to_value(self with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -433,7 +433,7 @@ def test_CentrifugalCompressor_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -441,7 +441,7 @@ def test_CentrifugalCompressor_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalCompressor() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -459,7 +459,7 @@ def test_CentrifugalCompressor_stream_connecion_disconnection_incorrect_type(sel with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_equipments/test_CentrifugalPump.py b/tests/test_equipments/test_CentrifugalPump.py index 2ff9a57..9a4d668 100644 --- a/tests/test_equipments/test_CentrifugalPump.py +++ b/tests/test_equipments/test_CentrifugalPump.py @@ -353,7 +353,7 @@ def test_CentrifugalPump_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -361,7 +361,7 @@ def test_CentrifugalPump_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -369,7 +369,7 @@ def test_CentrifugalPump_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -377,7 +377,7 @@ def test_CentrifugalPump_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -385,7 +385,7 @@ def test_CentrifugalPump_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -393,7 +393,7 @@ def test_CentrifugalPump_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -401,7 +401,7 @@ def test_CentrifugalPump_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -409,7 +409,7 @@ def test_CentrifugalPump_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -417,7 +417,7 @@ def test_CentrifugalPump_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -425,7 +425,7 @@ def test_CentrifugalPump_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -433,7 +433,7 @@ def test_CentrifugalPump_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -441,7 +441,7 @@ def test_CentrifugalPump_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -449,7 +449,7 @@ def test_CentrifugalPump_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = CentrifugalPump() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -461,7 +461,7 @@ def test_CentrifugalPump_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_equipments/test_ElectricHeater.py b/tests/test_equipments/test_ElectricHeater.py index 3b85f9b..4d8372d 100644 --- a/tests/test_equipments/test_ElectricHeater.py +++ b/tests/test_equipments/test_ElectricHeater.py @@ -305,7 +305,7 @@ def test_ElectricHeater_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -313,7 +313,7 @@ def test_ElectricHeater_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -321,7 +321,7 @@ def test_ElectricHeater_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -329,7 +329,7 @@ def test_ElectricHeater_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -337,7 +337,7 @@ def test_ElectricHeater_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -345,7 +345,7 @@ def test_ElectricHeater_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -353,7 +353,7 @@ def test_ElectricHeater_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -361,7 +361,7 @@ def test_ElectricHeater_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -369,7 +369,7 @@ def test_ElectricHeater_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -377,7 +377,7 @@ def test_ElectricHeater_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -385,7 +385,7 @@ def test_ElectricHeater_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -393,7 +393,7 @@ def test_ElectricHeater_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -401,7 +401,7 @@ def test_ElectricHeater_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ElectricHeater() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -413,7 +413,7 @@ def test_ElectricHeater_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_equipments/test_PipeSegment.py b/tests/test_equipments/test_PipeSegment.py index 7d8045a..73bdd0d 100644 --- a/tests/test_equipments/test_PipeSegment.py +++ b/tests/test_equipments/test_PipeSegment.py @@ -390,7 +390,7 @@ def test_PipeSegment_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -398,7 +398,7 @@ def test_PipeSegment_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @@ -407,7 +407,7 @@ def test_PipeSegment_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -415,7 +415,7 @@ def test_PipeSegment_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -423,7 +423,7 @@ def test_PipeSegment_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -431,7 +431,7 @@ def test_PipeSegment_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -439,7 +439,7 @@ def test_PipeSegment_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -447,7 +447,7 @@ def test_PipeSegment_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -455,7 +455,7 @@ def test_PipeSegment_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -463,7 +463,7 @@ def test_PipeSegment_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -471,7 +471,7 @@ def test_PipeSegment_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -479,7 +479,7 @@ def test_PipeSegment_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -487,7 +487,7 @@ def test_PipeSegment_length_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.length = [] - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -495,7 +495,7 @@ def test_PipeSegment_ID_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=[18, 'mm'], shape=(20, 18)) - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -503,7 +503,7 @@ def test_PipeSegment_OD_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.OD = [] - self.assertIn("Incorrect type 'list' provided to 'OD'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'OD'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -511,7 +511,7 @@ def test_PipeSegment_elevation_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=13, ID=(18, 'mm'), shape=(20, 18)) m4.elevation = [] - self.assertIn("Incorrect type 'list' provided to 'elevation'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'elevation'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -519,12 +519,12 @@ def test_PipeSegment_segmen_type_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(segment_type=[13], ID=(18, 'mm'), shape=(20, 18)) - self.assertIn("Incorrect type 'list' provided to 'segment_type'. Should be 'int'", + self.assertIn("Incorrect type 'list' provided to 'segment_type'. Should be \'int\'", str(exp)) with pytest.raises(Exception) as exp: m4 = PipeSegment(length=(10, "m"), ID=(18, 'mm'), shape=(20, 18)) m4.segment_type = [] - self.assertIn("Incorrect type 'list' provided to 'segment_type'. Should be 'int'", + self.assertIn("Incorrect type 'list' provided to 'segment_type'. Should be \'int\'", str(exp)) @pytest.mark.negative @@ -533,7 +533,7 @@ def test_PipeSegment_material_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PipeSegment(length=(10, "m"), ID=(18, 'mm'), shape=(20, 18)) m4.material = [] - self.assertIn("Incorrect type 'list' provided to 'material'. Should be 'int'", + self.assertIn("Incorrect type 'list' provided to 'material'. Should be \'int\'", str(exp)) @pytest.mark.negative @@ -545,7 +545,7 @@ def test_PipeSegment_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_equipments/test_PositiveDisplacementPump.py b/tests/test_equipments/test_PositiveDisplacementPump.py index d6af258..93d7a10 100644 --- a/tests/test_equipments/test_PositiveDisplacementPump.py +++ b/tests/test_equipments/test_PositiveDisplacementPump.py @@ -328,7 +328,7 @@ def test_PositiveDisplacementPump_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -336,7 +336,7 @@ def test_PositiveDisplacementPump_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -344,7 +344,7 @@ def test_PositiveDisplacementPump_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -352,7 +352,7 @@ def test_PositiveDisplacementPump_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -360,7 +360,7 @@ def test_PositiveDisplacementPump_inlet_temperature_incorrect_type_to_value(self with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -368,7 +368,7 @@ def test_PositiveDisplacementPump_outlet_temperature_incorrect_type_to_value(sel with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -376,7 +376,7 @@ def test_PositiveDisplacementPump_temperature_decrease_incorrect_type_to_value(s with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -384,7 +384,7 @@ def test_PositiveDisplacementPump_temperature_increase_incorrect_type_to_value(s with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -392,7 +392,7 @@ def test_PositiveDisplacementPump_design_temperature_incorrect_type_to_value(sel with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -400,7 +400,7 @@ def test_PositiveDisplacementPump_inlet_mass_flowrate_incorrect_type_to_value(se with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -408,7 +408,7 @@ def test_PositiveDisplacementPump_outlet_mass_flowrate_incorrect_type_to_value(s with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -416,7 +416,7 @@ def test_PositiveDisplacementPump_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -424,7 +424,7 @@ def test_PositiveDisplacementPump_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = PositiveDisplacementPump() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -436,7 +436,7 @@ def test_PositiveDisplacementPump_stream_connecion_disconnection_incorrect_type( with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_equipments/test_Sphere.py b/tests/test_equipments/test_Sphere.py index e2d6b00..de85245 100644 --- a/tests/test_equipments/test_Sphere.py +++ b/tests/test_equipments/test_Sphere.py @@ -23,7 +23,7 @@ def test_Sphere_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -31,7 +31,7 @@ def test_Sphere_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -39,7 +39,7 @@ def test_Sphere_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -47,7 +47,7 @@ def test_Sphere_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -55,7 +55,7 @@ def test_Sphere_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -63,7 +63,7 @@ def test_Sphere_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -71,7 +71,7 @@ def test_Sphere_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -79,7 +79,7 @@ def test_Sphere_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -87,7 +87,7 @@ def test_Sphere_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -95,7 +95,7 @@ def test_Sphere_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -103,7 +103,7 @@ def test_Sphere_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -111,7 +111,7 @@ def test_Sphere_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -119,7 +119,7 @@ def test_Sphere_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -128,12 +128,12 @@ def test_Sphere_ID_incorrect_type_to_value(self): horizontal_vessel = Sphere( ID=[4, "m"], length=(10, "m"), head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = Sphere() m4.ID = [] - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -142,12 +142,12 @@ def test_Sphere_length_incorrect_type_to_value(self): horizontal_vessel = Sphere( ID=(4, "m"), length=[10, "m"], head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = Sphere() m4.length = [] - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -156,12 +156,12 @@ def test_Sphere_heayd_type_incorrect_type_to_value(self): horizontal_vessel = Sphere( ID=(4, "m"), length=(10, "m"), head_type=["flat"]) - self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be 'str'", + self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be \'str\'", str(exp)) with pytest.raises(Exception) as exp: m4 = Sphere() m4.head_type = [] - self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be 'str'", + self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be \'str\'", str(exp)) @pytest.mark.negative @@ -169,7 +169,7 @@ def test_Sphere_LLLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.LLLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -177,7 +177,7 @@ def test_Sphere_LLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.LLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -185,7 +185,7 @@ def test_Sphere_NLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.NLL = [] - self.assertIn("Incorrect type 'list' provided to 'NLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'NLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -193,7 +193,7 @@ def test_Sphere_HLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.HLL = [] - self.assertIn("Incorrect type 'list' provided to 'HLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -201,7 +201,7 @@ def test_Sphere_HHLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.HHLL = [] - self.assertIn("Incorrect type 'list' provided to 'HHLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HHLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -209,7 +209,7 @@ def test_Sphere_operating_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.operating_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -217,7 +217,7 @@ def test_Sphere_operating_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.operating_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -226,12 +226,12 @@ def test_Sphere_heayd_type_incorrect_value(self): Vertical_vessel = Sphere( ID=(4, "m"), length=(10, "m"), head_type="flatop") - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) with pytest.raises(Exception) as exp: m4 = Sphere() m4.head_type = "flatop" - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) @pytest.mark.negative @@ -243,7 +243,7 @@ def test_Sphere_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: @@ -280,7 +280,7 @@ def test_Sphere_get_inventory_incorrect_type_to_type(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.get_inventory([]) - self.assertIn("Incorrect type 'list' provided to 'type'. Should be 'str", + self.assertIn("Incorrect type 'list' provided to 'type'. Should be \'str\'", str(exp)) @pytest.mark.negative @pytest.mark.get_inventory @@ -288,7 +288,7 @@ def test_Sphere_get_inventory_incorrect_value_to_type(self): with pytest.raises(Exception) as exp: m4 = Sphere() m4.get_inventory('list') - self.assertIn("Incorrect value \'list\' provided to \'type\'. Should be among \'[\'volume\', \'mass\']\'.", + self.assertIn("Incorrect value \'list\' provided to \'type\'. Can be any one from \'[\'volume\', \'mass\']\'.", str(exp)) @pytest.mark.mapping diff --git a/tests/test_equipments/test_Tank.py b/tests/test_equipments/test_Tank.py index 1f7f20e..13038e0 100644 --- a/tests/test_equipments/test_Tank.py +++ b/tests/test_equipments/test_Tank.py @@ -23,7 +23,7 @@ def test_Tank_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -31,7 +31,7 @@ def test_Tank_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -39,7 +39,7 @@ def test_Tank_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -47,7 +47,7 @@ def test_Tank_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -55,7 +55,7 @@ def test_Tank_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -63,7 +63,7 @@ def test_Tank_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -71,7 +71,7 @@ def test_Tank_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -79,7 +79,7 @@ def test_Tank_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -87,7 +87,7 @@ def test_Tank_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -95,7 +95,7 @@ def test_Tank_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -103,7 +103,7 @@ def test_Tank_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -111,7 +111,7 @@ def test_Tank_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -119,31 +119,31 @@ def test_Tank_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_Tank_ID_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: horizontal_vessel = Tank(ID=[4, "m"], length=(10, "m")) - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = Tank() m4.ID = [] - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_Tank_length_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: horizontal_vessel = Tank(ID=(4, "m"), length=[10, "m"]) - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = Tank() m4.length = [] - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @@ -153,7 +153,7 @@ def test_Tank_LLLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.LLLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -161,7 +161,7 @@ def test_Tank_LLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.LLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -169,7 +169,7 @@ def test_Tank_NLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.NLL = [] - self.assertIn("Incorrect type 'list' provided to 'NLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'NLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -177,7 +177,7 @@ def test_Tank_HLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.HLL = [] - self.assertIn("Incorrect type 'list' provided to 'HLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -185,7 +185,7 @@ def test_Tank_HHLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.HHLL = [] - self.assertIn("Incorrect type 'list' provided to 'HHLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HHLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -193,7 +193,7 @@ def test_Tank_operating_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.operating_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -201,7 +201,7 @@ def test_Tank_operating_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.operating_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -213,7 +213,7 @@ def test_Tank_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: @@ -250,7 +250,7 @@ def test_Tank_get_inventory_incorrect_type_to_type(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.get_inventory([]) - self.assertIn("Incorrect type 'list' provided to 'type'. Should be 'str", + self.assertIn("Incorrect type 'list' provided to 'type'. Should be \'str\'", str(exp)) @pytest.mark.negative @pytest.mark.get_inventory @@ -258,7 +258,7 @@ def test_Tank_get_inventory_incorrect_value_to_type(self): with pytest.raises(Exception) as exp: m4 = Tank() m4.get_inventory('list') - self.assertIn("Incorrect value \'list\' provided to \'type\'. Should be among \'[\'volume\', \'mass\']\'.", + self.assertIn("Incorrect value \'list\' provided to \'type\'. Can be any one from \'[\'volume\', \'mass\']\'.", str(exp)) @pytest.mark.mapping diff --git a/tests/test_equipments/test_TurboExpander.py b/tests/test_equipments/test_TurboExpander.py index d966a85..375a7ee 100644 --- a/tests/test_equipments/test_TurboExpander.py +++ b/tests/test_equipments/test_TurboExpander.py @@ -359,7 +359,7 @@ def test_TurboExpander_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -367,7 +367,7 @@ def test_TurboExpander_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -375,7 +375,7 @@ def test_TurboExpander_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -383,7 +383,7 @@ def test_TurboExpander_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -391,7 +391,7 @@ def test_TurboExpander_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -399,7 +399,7 @@ def test_TurboExpander_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -407,7 +407,7 @@ def test_TurboExpander_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -415,7 +415,7 @@ def test_TurboExpander_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -423,7 +423,7 @@ def test_TurboExpander_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -431,7 +431,7 @@ def test_TurboExpander_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -439,7 +439,7 @@ def test_TurboExpander_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = TurboExpander() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -457,7 +457,7 @@ def test_TurboExpander_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_equipments/test_VerticalStorage.py b/tests/test_equipments/test_VerticalStorage.py index 7a8260b..a8782b3 100644 --- a/tests/test_equipments/test_VerticalStorage.py +++ b/tests/test_equipments/test_VerticalStorage.py @@ -23,7 +23,7 @@ def test_VerticalStorage_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -31,7 +31,7 @@ def test_VerticalStorage_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -39,7 +39,7 @@ def test_VerticalStorage_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -47,7 +47,7 @@ def test_VerticalStorage_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -55,7 +55,7 @@ def test_VerticalStorage_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -63,7 +63,7 @@ def test_VerticalStorage_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -71,7 +71,7 @@ def test_VerticalStorage_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -79,7 +79,7 @@ def test_VerticalStorage_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -87,7 +87,7 @@ def test_VerticalStorage_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -95,7 +95,7 @@ def test_VerticalStorage_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -103,7 +103,7 @@ def test_VerticalStorage_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -111,7 +111,7 @@ def test_VerticalStorage_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -119,7 +119,7 @@ def test_VerticalStorage_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -128,12 +128,12 @@ def test_VerticalStorage_ID_incorrect_type_to_value(self): horizontal_vessel = VerticalStorage( ID=[4, "m"], length=(10, "m"), head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.ID = [] - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -142,12 +142,12 @@ def test_VerticalStorage_length_incorrect_type_to_value(self): horizontal_vessel = VerticalStorage( ID=(4, "m"), length=[10, "m"], head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.length = [] - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -156,12 +156,12 @@ def test_VerticalStorage_heayd_type_incorrect_type_to_value(self): horizontal_vessel = VerticalStorage( ID=(4, "m"), length=(10, "m"), head_type=["flat"]) - self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be 'str'", + self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be \'str\'", str(exp)) with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.head_type = [] - self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be 'str'", + self.assertIn("Incorrect type 'list' provided to 'head_type'. Should be \'str\'", str(exp)) @pytest.mark.negative @@ -169,7 +169,7 @@ def test_VerticalStorage_LLLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.LLLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -177,7 +177,7 @@ def test_VerticalStorage_LLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.LLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -185,7 +185,7 @@ def test_VerticalStorage_NLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.NLL = [] - self.assertIn("Incorrect type 'list' provided to 'NLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'NLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -193,7 +193,7 @@ def test_VerticalStorage_HLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.HLL = [] - self.assertIn("Incorrect type 'list' provided to 'HLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -201,7 +201,7 @@ def test_VerticalStorage_HHLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.HHLL = [] - self.assertIn("Incorrect type 'list' provided to 'HHLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HHLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -209,7 +209,7 @@ def test_VerticalStorage_operating_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.operating_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -217,7 +217,7 @@ def test_VerticalStorage_operating_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.operating_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -226,12 +226,12 @@ def test_VerticalStorage_heayd_type_incorrect_value(self): Vertical_vessel = VerticalStorage( ID=(4, "m"), length=(10, "m"), head_type="flatop") - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.head_type = "flatop" - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) @pytest.mark.negative @@ -243,7 +243,7 @@ def test_VerticalStorage_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: @@ -280,7 +280,7 @@ def test_VerticalStorage_get_inventory_incorrect_type_to_type(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.get_inventory([]) - self.assertIn("Incorrect type 'list' provided to 'type'. Should be 'str", + self.assertIn("Incorrect type 'list' provided to 'type'. Should be \'str\'", str(exp)) @pytest.mark.negative @pytest.mark.get_inventory @@ -288,7 +288,7 @@ def test_VerticalStorage_get_inventory_incorrect_value_to_type(self): with pytest.raises(Exception) as exp: m4 = VerticalStorage() m4.get_inventory('list') - self.assertIn("Incorrect value \'list\' provided to \'type\'. Should be among \'[\'volume\', \'mass\']\'.", + self.assertIn("Incorrect value \'list\' provided to \'type\'. Can be any one from \'[\'volume\', \'mass\']\'.", str(exp)) @pytest.mark.mapping diff --git a/tests/test_equipments/test__HorizontalVessels.py b/tests/test_equipments/test__HorizontalVessels.py index 0d1e2df..1472aa2 100644 --- a/tests/test_equipments/test__HorizontalVessels.py +++ b/tests/test_equipments/test__HorizontalVessels.py @@ -431,7 +431,7 @@ def test__HorizontalVessels_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -439,7 +439,7 @@ def test__HorizontalVessels_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -447,7 +447,7 @@ def test__HorizontalVessels_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -455,7 +455,7 @@ def test__HorizontalVessels_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -463,7 +463,7 @@ def test__HorizontalVessels_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -471,7 +471,7 @@ def test__HorizontalVessels_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -479,7 +479,7 @@ def test__HorizontalVessels_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -487,7 +487,7 @@ def test__HorizontalVessels_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -495,7 +495,7 @@ def test__HorizontalVessels_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -503,7 +503,7 @@ def test__HorizontalVessels_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -511,7 +511,7 @@ def test__HorizontalVessels_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -519,7 +519,7 @@ def test__HorizontalVessels_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -527,7 +527,7 @@ def test__HorizontalVessels_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -536,12 +536,12 @@ def test__HorizontalVessels_ID_incorrect_type_to_value(self): horizontal_vessel = _HorizontalVessels( ID=[4, "m"], length=(10, "m"), head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.ID = [] - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -550,12 +550,12 @@ def test__HorizontalVessels_length_incorrect_type_to_value(self): horizontal_vessel = _HorizontalVessels( ID=(4, "m"), length=[10, "m"], head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.length = [] - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -577,12 +577,12 @@ def test__HorizontalVessels_heayd_type_incorrect_value(self): horizontal_vessel = _HorizontalVessels( ID=(4, "m"), length=(10, "m"), head_type="flatop") - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.head_type = "flatop" - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) @pytest.mark.negative @@ -590,7 +590,7 @@ def test__HorizontalVessels_LLLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.LLLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -598,7 +598,7 @@ def test__HorizontalVessels_LLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.LLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -606,7 +606,7 @@ def test__HorizontalVessels_NLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.NLL = [] - self.assertIn("Incorrect type 'list' provided to 'NLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'NLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -614,7 +614,7 @@ def test__HorizontalVessels_HLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.HLL = [] - self.assertIn("Incorrect type 'list' provided to 'HLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -622,7 +622,7 @@ def test__HorizontalVessels_HHLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.HHLL = [] - self.assertIn("Incorrect type 'list' provided to 'HHLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HHLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -630,7 +630,7 @@ def test__HorizontalVessels_operating_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.operating_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -638,7 +638,7 @@ def test__HorizontalVessels_operating_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.operating_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -655,7 +655,7 @@ def test__HorizontalVessels_get_inventory_incorrect_value_to_type(self): with pytest.raises(Exception) as exp: m4 = _HorizontalVessels() m4.get_inventory('list') - self.assertIn("Incorrect value \'list\' provided to \'type\'. Should be among \'[\'volume\', \'mass\']\'.", + self.assertIn("Incorrect value \'list\' provided to \'type\'. Can be any one from \'[\'volume\', \'mass\']\'.", str(exp)) @pytest.mark.negative @@ -666,7 +666,7 @@ def test__HorizontalVessels_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_equipments/test__SphericalVessels.py b/tests/test_equipments/test__SphericalVessels.py index ad60ba0..48c88eb 100644 --- a/tests/test_equipments/test__SphericalVessels.py +++ b/tests/test_equipments/test__SphericalVessels.py @@ -312,7 +312,7 @@ def test__SphericalVessels_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -320,7 +320,7 @@ def test__SphericalVessels_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -328,7 +328,7 @@ def test__SphericalVessels_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -336,7 +336,7 @@ def test__SphericalVessels_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -344,7 +344,7 @@ def test__SphericalVessels_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -352,7 +352,7 @@ def test__SphericalVessels_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -360,7 +360,7 @@ def test__SphericalVessels_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -368,7 +368,7 @@ def test__SphericalVessels_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -376,7 +376,7 @@ def test__SphericalVessels_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -384,7 +384,7 @@ def test__SphericalVessels_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -392,7 +392,7 @@ def test__SphericalVessels_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -400,7 +400,7 @@ def test__SphericalVessels_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -408,7 +408,7 @@ def test__SphericalVessels_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -417,12 +417,12 @@ def test__SphericalVessels_ID_incorrect_type_to_value(self): Spherical_vessel = _SphericalVessels( ID=[4, "m"], length=(10, "m"), head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.ID = [] - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -431,12 +431,12 @@ def test__SphericalVessels_length_incorrect_type_to_value(self): Spherical_vessel = _SphericalVessels( ID=(4, "m"), length=[10, "m"], head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.length = [] - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -458,7 +458,7 @@ def test__SphericalVessels_LLLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.LLLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -466,7 +466,7 @@ def test__SphericalVessels_LLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.LLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -474,7 +474,7 @@ def test__SphericalVessels_NLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.NLL = [] - self.assertIn("Incorrect type 'list' provided to 'NLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'NLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -482,7 +482,7 @@ def test__SphericalVessels_HLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.HLL = [] - self.assertIn("Incorrect type 'list' provided to 'HLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -490,7 +490,7 @@ def test__SphericalVessels_HHLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.HHLL = [] - self.assertIn("Incorrect type 'list' provided to 'HHLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HHLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -498,7 +498,7 @@ def test__SphericalVessels_operating_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.operating_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -506,7 +506,7 @@ def test__SphericalVessels_operating_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.operating_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -515,12 +515,12 @@ def test__SphericalVessels_heayd_type_incorrect_value(self): Spherical_vessel = _SphericalVessels( ID=(4, "m"), length=(10, "m"), head_type="flatop") - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.head_type = "flatop" - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) @pytest.mark.negative @@ -531,7 +531,7 @@ def test__SphericalVessels_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: @@ -567,7 +567,7 @@ def test__SphericalVessels_get_inventory_incorrect_type_to_type(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.get_inventory([]) - self.assertIn("Incorrect type 'list' provided to 'type'. Should be 'str", + self.assertIn("Incorrect type 'list' provided to 'type'. Should be \'str\'", str(exp)) @pytest.mark.negative @pytest.mark.get_inventory @@ -575,5 +575,5 @@ def test__SphericalVessels_get_inventory_incorrect_value_to_type(self): with pytest.raises(Exception) as exp: m4 = _SphericalVessels() m4.get_inventory('list') - self.assertIn("Incorrect value \'list\' provided to \'type\'. Should be among \'[\'volume\', \'mass\']\'.", + self.assertIn("Incorrect value \'list\' provided to \'type\'. Can be any one from \'[\'volume\', \'mass\']\'.", str(exp)) \ No newline at end of file diff --git a/tests/test_equipments/test__VerticalVessels.py b/tests/test_equipments/test__VerticalVessels.py index ddc2457..70de924 100644 --- a/tests/test_equipments/test__VerticalVessels.py +++ b/tests/test_equipments/test__VerticalVessels.py @@ -428,7 +428,7 @@ def test__VerticalVessels_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -436,7 +436,7 @@ def test__VerticalVessels_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -444,7 +444,7 @@ def test__VerticalVessels_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -452,7 +452,7 @@ def test__VerticalVessels_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -460,7 +460,7 @@ def test__VerticalVessels_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -468,7 +468,7 @@ def test__VerticalVessels_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -476,7 +476,7 @@ def test__VerticalVessels_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -484,7 +484,7 @@ def test__VerticalVessels_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -492,7 +492,7 @@ def test__VerticalVessels_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -500,7 +500,7 @@ def test__VerticalVessels_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -508,7 +508,7 @@ def test__VerticalVessels_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -516,7 +516,7 @@ def test__VerticalVessels_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -524,7 +524,7 @@ def test__VerticalVessels_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -533,12 +533,12 @@ def test__VerticalVessels_ID_incorrect_type_to_value(self): Veritcal_vessel = _VerticalVessels( ID=[4, "m"], length=(10, "m"), head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.ID = [] - self.assertIn("Incorrect type 'list' provided to 'ID'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'ID'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -547,12 +547,12 @@ def test__VerticalVessels_length_incorrect_type_to_value(self): Veritcal_vessel = _VerticalVessels( ID=(4, "m"), length=[10, "m"], head_type="flat") - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.length = [] - self.assertIn("Incorrect type 'list' provided to 'length'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'length'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -574,7 +574,7 @@ def test__VerticalVessels_LLLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.LLLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -582,7 +582,7 @@ def test__VerticalVessels_LLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.LLL = [] - self.assertIn("Incorrect type 'list' provided to 'LLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'LLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -590,7 +590,7 @@ def test__VerticalVessels_NLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.NLL = [] - self.assertIn("Incorrect type 'list' provided to 'NLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'NLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -598,7 +598,7 @@ def test__VerticalVessels_HLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.HLL = [] - self.assertIn("Incorrect type 'list' provided to 'HLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -606,7 +606,7 @@ def test__VerticalVessels_HHLL_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.HHLL = [] - self.assertIn("Incorrect type 'list' provided to 'HHLL'. Should be '('Length', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'HHLL'. Can be any one from '('Length', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -614,7 +614,7 @@ def test__VerticalVessels_operating_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.operating_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -622,7 +622,7 @@ def test__VerticalVessels_operating_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.operating_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'operating_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -631,12 +631,12 @@ def test__VerticalVessels_heayd_type_incorrect_value(self): Vertical_vessel = _VerticalVessels( ID=(4, "m"), length=(10, "m"), head_type="flatop") - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.head_type = "flatop" - self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Should be among \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", + self.assertIn("Incorrect value \'flatop\' provided to \'head_type\'. Can be any one from \'[\'hemispherical\', \'elliptical\', \'torispherical\', \'flat\']\'", str(exp)) @pytest.mark.negative @@ -647,7 +647,7 @@ def test__VerticalVessels_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: @@ -683,7 +683,7 @@ def test__VerticalVessels_get_inventory_incorrect_type_to_type(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.get_inventory([]) - self.assertIn("Incorrect type 'list' provided to 'type'. Should be 'str", + self.assertIn("Incorrect type 'list' provided to 'type'. Should be \'str\'", str(exp)) @pytest.mark.negative @pytest.mark.get_inventory @@ -691,5 +691,5 @@ def test__VerticalVessels_get_inventory_incorrect_value_to_type(self): with pytest.raises(Exception) as exp: m4 = _VerticalVessels() m4.get_inventory('list') - self.assertIn("Incorrect value \'list\' provided to \'type\'. Should be among \'[\'volume\', \'mass\']\'.", + self.assertIn("Incorrect value \'list\' provided to \'type\'. Can be any one from \'[\'volume\', \'mass\']\'.", str(exp)) \ No newline at end of file diff --git a/tests/test_instruments/test_ControlValve.py b/tests/test_instruments/test_ControlValve.py index ef669d7..6df003a 100644 --- a/tests/test_instruments/test_ControlValve.py +++ b/tests/test_instruments/test_ControlValve.py @@ -269,7 +269,7 @@ def test_ControlValve_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -277,7 +277,7 @@ def test_ControlValve_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -285,7 +285,7 @@ def test_ControlValve_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -293,7 +293,7 @@ def test_ControlValve_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -301,7 +301,7 @@ def test_ControlValve_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -309,7 +309,7 @@ def test_ControlValve_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -317,7 +317,7 @@ def test_ControlValve_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -325,7 +325,7 @@ def test_ControlValve_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -333,7 +333,7 @@ def test_ControlValve_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -341,7 +341,7 @@ def test_ControlValve_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -349,7 +349,7 @@ def test_ControlValve_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -357,7 +357,7 @@ def test_ControlValve_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -365,7 +365,7 @@ def test_ControlValve_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = ControlValve() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -377,7 +377,7 @@ def test_ControlValve_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_instruments/test_FlowMeter.py b/tests/test_instruments/test_FlowMeter.py index b981271..26692b9 100644 --- a/tests/test_instruments/test_FlowMeter.py +++ b/tests/test_instruments/test_FlowMeter.py @@ -242,7 +242,7 @@ def test_FlowMeter_inlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.inlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -250,7 +250,7 @@ def test_FlowMeter_outlet_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.outlet_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -258,7 +258,7 @@ def test_FlowMeter_pressure_drop_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.pressure_drop = [] - self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure_drop'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -266,7 +266,7 @@ def test_FlowMeter_design_pressure_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.design_pressure = [] - self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -274,7 +274,7 @@ def test_FlowMeter_inlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.inlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -282,7 +282,7 @@ def test_FlowMeter_outlet_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.outlet_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -290,7 +290,7 @@ def test_FlowMeter_temperature_decrease_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.temperature_decrease = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_decrease'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -298,7 +298,7 @@ def test_FlowMeter_temperature_increase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.temperature_increase = [] - self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature_increase'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -306,7 +306,7 @@ def test_FlowMeter_design_temperature_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.design_temperature = [] - self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -314,7 +314,7 @@ def test_FlowMeter_inlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.inlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'inlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -322,7 +322,7 @@ def test_FlowMeter_outlet_mass_flowrate_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.outlet_mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'outlet_mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -330,7 +330,7 @@ def test_FlowMeter_energy_in_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.energy_in = [] - self.assertIn("Incorrect type 'list' provided to 'energy_in'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_in'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -338,7 +338,7 @@ def test_FlowMeter_energy_out_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = FlowMeter() m4.energy_out = [] - self.assertIn("Incorrect type 'list' provided to 'energy_out'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'energy_out'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative @@ -349,7 +349,7 @@ def test_FlowMeter_stream_connecion_disconnection_incorrect_type(self): with pytest.raises(Exception) as exp: cv.connect_stream([inlet_stream], 'in', stream_governed=True) - self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Should be \'('MaterialStream', 'EnergyStream')\'", + self.assertIn("Incorrect type \'list\' provided to \'stream_object\'. Can be any one from \'('MaterialStream', 'EnergyStream')\'", str(exp)) with pytest.raises(Exception) as exp: diff --git a/tests/test_instruments/test_PressureGuage.py b/tests/test_instruments/test_PressureGuage.py new file mode 100644 index 0000000..bbe2080 --- /dev/null +++ b/tests/test_instruments/test_PressureGuage.py @@ -0,0 +1,83 @@ +import pytest +import unittest +from propylean.instruments.measurement import PressureGuage +from propylean.streams import MaterialStream, EnergyStream +import propylean.properties as prop + +class test_PressureGuage(unittest.TestCase): + @pytest.mark.positive + @pytest.mark.instantiation + def test_PressureGuage_instantiation_only_tag(self): + pg_1 = PressureGuage(tag="PG-101") + self.assertEqual(pg_1.tag, "PG-101") + + @pytest.mark.positive + @pytest.mark.instantiation + def test_PressureGuage_instantiation_tag_and_pressure(self): + pressure_guage = PressureGuage(tag="pressure_guage_2", + measured_unit='bar') + self.assertEqual(pressure_guage.tag, "pressure_guage_2") + self.assertEqual(pressure_guage.measured_property, prop.Pressure) + self.assertEqual(pressure_guage.measured_unit, 'bar') + + @pytest.mark.positive + @pytest.mark.instantiation + def test_PressureGuage_instantiation_no_arguments(self): + pressure_guage = PressureGuage() + self.assertIsNotNone(pressure_guage.tag) + self.assertEqual(pressure_guage.measured_property, prop.Pressure) + self.assertEqual(pressure_guage.measured_unit, 'Pa') + + @pytest.mark.positive + def test_PressureGuage_representation(self): + pressure_guage = PressureGuage(tag="pressure_guage_5") + self.assertIn("PressureGuage with tag: pressure_guage_5", str(pressure_guage)) + + @pytest.mark.negative + def test_PressureGuage_measured_unit_incorrect_type_to_value(self): + with pytest.raises(Exception) as exp: + m4 = PressureGuage() + m4.measured_unit = [] + self.assertIn("Incorrect type 'list' provided to 'measured_unit'. Should be 'str'", + str(exp)) + + @pytest.mark.negative + def test_PressureGuage_measured_property_incorrect_type_to_value(self): + with pytest.raises(Exception) as exp: + m4 = PressureGuage() + m4.measured_property = [] + self.assertIn("Cannot set measured_property of PressureGuage", + str(exp)) + + @pytest.mark.negative + def test_PressureGuage_i_range_incorrect_type_to_value(self): + with pytest.raises(Exception) as exp: + m4 = PressureGuage() + m4.i_range = [] + self.assertIn("Incorrect type 'list' provided to 'i_range'. Should be 'tuple'", + str(exp)) + + # @pytest.mark.negative + # def test_PressureGuage_design_pressure_incorrect_type_to_value(self): + # with pytest.raises(Exception) as exp: + # m4 = PressureGuage() + # m4.design_pressure = [] + # self.assertIn("Incorrect type 'list' provided to 'design_pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", + # str(exp)) + + + @pytest.mark.negative + def test_PressureGuage_resolution_incorrect_type_to_value(self): + with pytest.raises(Exception) as exp: + m4 = PressureGuage() + m4.resolution = [] + self.assertIn("Incorrect type 'list' provided to 'resolution'. Can be any one from '('int', 'float')'", + str(exp)) + + @pytest.mark.negative + def test_PressureGuage_resolution_incorrect_value_to_value(self): + with pytest.raises(Exception) as exp: + m4 = PressureGuage() + m4.resolution = -1 + self.assertIn("Value passed to 'resolution' should be greater than 0.", + str(exp)) diff --git a/tests/test_instruments/test_TemperatureGuage.py b/tests/test_instruments/test_TemperatureGuage.py new file mode 100644 index 0000000..d85dd29 --- /dev/null +++ b/tests/test_instruments/test_TemperatureGuage.py @@ -0,0 +1,83 @@ +import pytest +import unittest +from propylean.instruments.measurement import TemperatureGuage +from propylean.streams import MaterialStream, EnergyStream +import propylean.properties as prop + +class test_TemperatureGuage(unittest.TestCase): + @pytest.mark.positive + @pytest.mark.instantiation + def test_TemperatureGuage_instantiation_only_tag(self): + pg_1 = TemperatureGuage(tag="PG-101") + self.assertEqual(pg_1.tag, "PG-101") + + @pytest.mark.positive + @pytest.mark.instantiation + def test_TemperatureGuage_instantiation_tag_and_temperature(self): + temperature_guage = TemperatureGuage(tag="temperature_guage_2", + measured_unit='C') + self.assertEqual(temperature_guage.tag, "temperature_guage_2") + self.assertEqual(temperature_guage.measured_property, prop.Temperature) + self.assertEqual(temperature_guage.measured_unit, 'C') + + @pytest.mark.positive + @pytest.mark.instantiation + def test_TemperatureGuage_instantiation_no_arguments(self): + temperature_guage = TemperatureGuage() + self.assertIsNotNone(temperature_guage.tag) + self.assertEqual(temperature_guage.measured_property, prop.Temperature) + self.assertEqual(temperature_guage.measured_unit, 'C') + + @pytest.mark.positive + def test_TemperatureGuage_representation(self): + temperature_guage = TemperatureGuage(tag="temperature_guage_5") + self.assertIn("TemperatureGuage with tag: temperature_guage_5", str(temperature_guage)) + + @pytest.mark.negative + def test_TemperatureGuage_measured_unit_incorrect_type_to_value(self): + with pytest.raises(Exception) as exp: + m4 = TemperatureGuage() + m4.measured_unit = [] + self.assertIn("Incorrect type 'list' provided to 'measured_unit'. Should be 'str'", + str(exp)) + + @pytest.mark.negative + def test_TemperatureGuage_measured_property_incorrect_type_to_value(self): + with pytest.raises(Exception) as exp: + m4 = TemperatureGuage() + m4.measured_property = [] + self.assertIn("Cannot set measured_property of TemperatureGuage", + str(exp)) + + @pytest.mark.negative + def test_TemperatureGuage_i_range_incorrect_type_to_value(self): + with pytest.raises(Exception) as exp: + m4 = TemperatureGuage() + m4.i_range = [] + self.assertIn("Incorrect type 'list' provided to 'i_range'. Should be 'tuple'", + str(exp)) + + # @pytest.mark.negative + # def test_TemperatureGuage_design_temperature_incorrect_type_to_value(self): + # with pytest.raises(Exception) as exp: + # m4 = TemperatureGuage() + # m4.design_temperature = [] + # self.assertIn("Incorrect type 'list' provided to 'design_temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", + # str(exp)) + + + @pytest.mark.negative + def test_TemperatureGuage_resolution_incorrect_type_to_value(self): + with pytest.raises(Exception) as exp: + m4 = TemperatureGuage() + m4.resolution = [] + self.assertIn("Incorrect type 'list' provided to 'resolution'. Can be any one from '('int', 'float')'", + str(exp)) + + @pytest.mark.negative + def test_TemperatureGuage_resolution_incorrect_value_to_value(self): + with pytest.raises(Exception) as exp: + m4 = TemperatureGuage() + m4.resolution = -1 + self.assertIn("Value passed to 'resolution' should be greater than 0.", + str(exp)) diff --git a/tests/test_properties/test_properties.py b/tests/test_properties/test_properties.py index f77dd35..699b7c7 100644 --- a/tests/test_properties/test_properties.py +++ b/tests/test_properties/test_properties.py @@ -31,23 +31,23 @@ def test_Length_incorrect_instantiation(): def test_Length_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.Length([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.Length() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_Length_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.Length(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.Length() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.positive def test_Time_instantiation_conversion(): @@ -76,21 +76,21 @@ def test_Time_incorrect_instantiation(): def test_Time_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.Time([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.Time() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_Time_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.Time(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.Time() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.positive def test_Pressure_instantiation_conversion(): @@ -119,22 +119,22 @@ def test_Pressure_incorrect_instantiation_conversion(): def test_Pressure_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.Pressure([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.Pressure() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_Pressure_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.Pressure(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.Length() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.positive def test_Temperature_instantiation_conversion(): @@ -169,21 +169,21 @@ def test_Temperature_incorrect_instantiation_conversion(): def test_Temperature_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.Temperature([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.Temperature() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_Temperature_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.Temperature(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.Temperature() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.positive def test_MassFlowRate_instantiation_conversion(): @@ -216,22 +216,22 @@ def test_MassFlowRate_incorrect_instantiatio_conversion(): def test_MassFlowRate_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.MassFlowRate([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.MassFlowRate() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_MassFlowRate_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.MassFlowRate(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.MassFlowRate() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.positive def test_MolarFlowRate_instantiation_conversion(): @@ -261,22 +261,22 @@ def test_MolarFlowRate_incorrect_instantiation_conversion(): def test_MolarFlowRate_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.MolarFlowRate([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.MolarFlowRate() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_MolarFlowRate_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.MolarFlowRate(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.Length() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.positive def test_VolumeFlowRate_instantiation_conversion(): @@ -305,22 +305,22 @@ def test_VolumeFlowRate_incorrect_instantiation_conversion(): def test_VolumetricFlowRate_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.VolumetricFlowRate([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.VolumetricFlowRate() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_VolumetricFlowRate_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.VolumetricFlowRate(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.Length() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.positive def test_Power_instantiation_conversion(): @@ -358,21 +358,21 @@ def test_Power_instantiation_conversion(): def test_Power_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.Power([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.Power() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_Power_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.Power(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.Power() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.positive @@ -389,22 +389,22 @@ def test_property_density(): def test_Density_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.Density([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.Density() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_Desnisty_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.Density(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.Length() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.positive def test_property_dviscosity(): @@ -418,22 +418,22 @@ def test_property_dviscosity(): def test_DViscosity_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.DViscosity([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.DViscosity() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_DViscosity_incorrect_type_to_unit(): with pytest.raises(Exception) as exp: properties.DViscosity(10, 10) - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) with pytest.raises(Exception) as exp: l = properties.Length() l.unit = 10 - assert "Incorrect type 'int' provided to 'unit'. Should be 'str'." in str(exp) + assert "Incorrect type 'int' provided to 'unit'. Should be \'str\'." in str(exp) @pytest.mark.addition def test_property_addition(): @@ -486,68 +486,69 @@ def test_property_different_not_equal(): m = properties.MassFlowRate() assert not t==m -@pytest.mark.positive -@pytest.mark.time_series -def test_property_time_series_passed_series(): - p = properties._Property() - idx = pd.date_range("2018-01-01", periods=5, freq="H") - ts = pd.Series(range(len(idx)), index=idx) - p.time_series = ts - assert ts.equals(p.time_series) - assert p.time_series.equals(ts) - -@pytest.mark.positive -@pytest.mark.time_series -def test_property_time_series_passed_dataframe(): - p = properties._Property() - idx = pd.date_range("2018-01-01", periods=5, freq="H") - ts = pd.DataFrame(range(len(idx)), index=idx) - p.time_series = ts - assert ts[0].equals(p.time_series) - assert p.time_series.equals(ts[0]) - - ts_2 = pd.DataFrame({0:idx, 1:range(len(idx))}) - - p.time_series = ts_2 +# A series cannot be a property of physical property. +# @pytest.mark.positive +# @pytest.mark.time_series +# def test_property_time_series_passed_series(): +# p = properties._Property() +# idx = pd.date_range("2018-01-01", periods=5, freq="H") +# ts = pd.Series(range(len(idx)), index=idx) +# p.time_series = ts +# assert ts.equals(p.time_series) +# assert p.time_series.equals(ts) + +# @pytest.mark.positive +# @pytest.mark.time_series +# def test_property_time_series_passed_dataframe(): +# p = properties._Property() +# idx = pd.date_range("2018-01-01", periods=5, freq="H") +# ts = pd.DataFrame(range(len(idx)), index=idx) +# p.time_series = ts +# assert ts[0].equals(p.time_series) +# assert p.time_series.equals(ts[0]) + +# ts_2 = pd.DataFrame({0:idx, 1:range(len(idx))}) + +# p.time_series = ts_2 - assert ts[0].equals(p.time_series) - assert p.time_series.equals(ts[0]) - -@pytest.mark.positive -@pytest.mark.time_series -def test_property_time_series_passed_dict(): - p = properties._Property() - idx = pd.date_range("2018-01-01", periods=5, freq="H") - ts = pd.Series(range(len(idx)), index=idx) - - data_dict = {} - for i in range(len(idx)): - data_dict[idx[i]] = i - p.time_series = data_dict - assert ts.equals(p.time_series) - assert p.time_series.equals(ts) - -@pytest.mark.positive -@pytest.mark.time_series -def test_property_time_series_series_property_arribute_match(): - """ - Property's attribute should match time_series attribute when - time_series provided. - """ - p1 = properties._Property() - idx = pd.date_range("2018-01-01", periods=5, freq="H") - ts = pd.Series(range(len(idx)), index=idx) - p1.time_series = ts - prp = ["min", "max", "mean", "median", "mode"] - for p in prp: - assert getattr(p1, p) == getattr(p1.time_series, p) - -@pytest.mark.negative -def test_time_series_incorrect_type_to_value(): - with pytest.raises(Exception) as exp: - l = properties.Length(10) - l.time_series = [] - assert "Incorrect type 'list' provided to 'time_series'. Should be '('Series', 'DataFrame', 'dict')" in str(exp) +# assert ts[0].equals(p.time_series) +# assert p.time_series.equals(ts[0]) + +# @pytest.mark.positive +# @pytest.mark.time_series +# def test_property_time_series_passed_dict(): +# p = properties._Property() +# idx = pd.date_range("2018-01-01", periods=5, freq="H") +# ts = pd.Series(range(len(idx)), index=idx) + +# data_dict = {} +# for i in range(len(idx)): +# data_dict[idx[i]] = i +# p.time_series = data_dict +# assert ts.equals(p.time_series) +# assert p.time_series.equals(ts) + +# @pytest.mark.positive +# @pytest.mark.time_series +# def test_property_time_series_series_property_arribute_match(): +# """ +# Property's attribute should match time_series attribute when +# time_series provided. +# """ +# p1 = properties._Property() +# idx = pd.date_range("2018-01-01", periods=5, freq="H") +# ts = pd.Series(range(len(idx)), index=idx) +# p1.time_series = ts +# prp = ["min", "max", "mean", "median", "mode"] +# for p in prp: +# assert getattr(p1, p) == getattr(p1.time_series, p) + +# @pytest.mark.negative +# def test_time_series_incorrect_type_to_value(): +# with pytest.raises(Exception) as exp: +# l = properties.Length(10) +# l.time_series = [] +# assert "Incorrect type 'list' provided to 'time_series'. Can be any one from '('Series', 'DataFrame', 'dict')" in str(exp) @pytest.mark.positive def test_property_Efficiency(): @@ -560,11 +561,11 @@ def test_property_Efficiency(): def test_Efficiency_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.Efficiency([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.Efficiency() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_Efficiency_setting_unit(): @@ -586,11 +587,11 @@ def test_property_Dimensionless(): def test_Dimensionless_incorrect_type_to_value(): with pytest.raises(Exception) as exp: properties.Dimensionless([10]) - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) with pytest.raises(Exception) as exp: l = properties.Dimensionless() l.value = [] - assert "Incorrect type 'list' provided to 'value'. Should be '('int', 'float')" in str(exp) + assert "Incorrect type 'list' provided to 'value'. Can be any one from '('int', 'float')" in str(exp) @pytest.mark.negative def test_Dimensionless_setting_unit(): diff --git a/tests/test_series/__init__.py b/tests/test_series/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_streams/test_EnergyStream.py b/tests/test_streams/test_EnergyStream.py index 3b9b4e3..cb93529 100644 --- a/tests/test_streams/test_EnergyStream.py +++ b/tests/test_streams/test_EnergyStream.py @@ -32,13 +32,13 @@ def test_EnergyStream_object_representation(self): def test_EnergyStream_incorrect_assignment(self): with pytest.raises(Exception) as exp: e5 = EnergyStream("gggg", []) - self.assertIn("Incorrect type 'list' provided to 'amount'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'amount'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: e5 = EnergyStream() e5.amount = [] - self.assertIn("Incorrect type 'list' provided to 'amount'. Should be '('Power', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'amount'. Can be any one from '('Power', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.delete diff --git a/tests/test_streams/test_MaterialStream.py b/tests/test_streams/test_MaterialStream.py index 2648b58..6b80b69 100644 --- a/tests/test_streams/test_MaterialStream.py +++ b/tests/test_streams/test_MaterialStream.py @@ -87,7 +87,7 @@ def test_MaterialStream_components_flow_property_volumetric_flowrate(self): mx = Mixture(zs=mol_fraction, T=300, P=p.value) m4.vol_flowrate.unit = "m^3/h" expected_volumetric_flowrate = 1000/mx.rho - self.assertEqual(m4.vol_flowrate.value, expected_volumetric_flowrate) + self.assertAlmostEqual(m4.vol_flowrate.value, expected_volumetric_flowrate) @pytest.mark.positive def test_MaterialStream_components_flow_property_mol_flowrate(self): @@ -183,12 +183,12 @@ def test_MaterialStream_pressure_incorrect_type_to_value(self): m4 = MaterialStream(pressure=[10], temperature=300, mass_flowrate=prop.MassFlowRate(1000, "kg/h")) - self.assertIn("Incorrect type 'list' provided to 'pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.pressure = [] - self.assertIn("Incorrect type 'list' provided to 'pressure'. Should be '('Pressure', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'pressure'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_temperature_incorrect_type_to_value(self): @@ -196,12 +196,12 @@ def test_MaterialStream_temperature_incorrect_type_to_value(self): m4 = MaterialStream(pressure=10, temperature=[300], mass_flowrate=prop.MassFlowRate(1000, "kg/h")) - self.assertIn("Incorrect type 'list' provided to 'temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.temperature = [] - self.assertIn("Incorrect type 'list' provided to 'temperature'. Should be '('Temperature', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'temperature'. Can be any one from '('Temperature', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_mass_flowrate_incorrect_type_to_value(self): @@ -209,19 +209,19 @@ def test_MaterialStream_mass_flowrate_incorrect_type_to_value(self): m4 = MaterialStream(pressure=10, temperature=300, mass_flowrate=[]) - self.assertIn("Incorrect type 'list' provided to 'mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", + self.assertIn("Incorrect type 'list' provided to 'mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.mass_flowrate = [] - self.assertIn("Incorrect type 'list' provided to 'mass_flowrate'. Should be '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'mass_flowrate'. Can be any one from '('MassFlowRate', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_molecular_weigth_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.molecular_weight = [] - self.assertIn("Incorrect type 'list' provided to 'molecular_weight'. Should be '('MolecularWeigth', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'molecular_weight'. Can be any one from '('MolecularWeigth', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_components_incorrect_type_to_value(self): @@ -235,98 +235,98 @@ def test_MaterialStream_desnity_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.density = [] - self.assertIn("Incorrect type 'list' provided to 'density'. Should be '('Density', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'density'. Can be any one from '('Density', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_desnity_l_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.density_l = [] - self.assertIn("Incorrect type 'list' provided to 'density_l'. Should be '('Density', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'density_l'. Can be any one from '('Density', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_desnity_g_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.density_g = [] - self.assertIn("Incorrect type 'list' provided to 'density_g'. Should be '('Density', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'density_g'. Can be any one from '('Density', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_desnity_s_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.density_s = [] - self.assertIn("Incorrect type 'list' provided to 'density_s'. Should be '('Density', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'density_s'. Can be any one from '('Density', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_d_viscosity_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.d_viscosity = [] - self.assertIn("Incorrect type 'list' provided to 'd_viscosity'. Should be '('DViscosity', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'd_viscosity'. Can be any one from '('DViscosity', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_d_viscosity_l_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.d_viscosity_l = [] - self.assertIn("Incorrect type 'list' provided to 'd_viscosity_l'. Should be '('DViscosity', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'd_viscosity_l'. Can be any one from '('DViscosity', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_d_viscosity_g_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.d_viscosity_g = [] - self.assertIn("Incorrect type 'list' provided to 'd_viscosity_g'. Should be '('DViscosity', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'd_viscosity_g'. Can be any one from '('DViscosity', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_isentropic_exponent_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.isentropic_exponent = [] - self.assertIn("Incorrect type 'list' provided to 'isentropic_exponent'. Should be '('Dimensionless', 'int', 'float')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'isentropic_exponent'. Can be any one from '('Dimensionless', 'int', 'float')'", str(exp)) @pytest.mark.negative def test_MaterialStream_phase_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.phase = [] - self.assertIn("Incorrect type 'list' provided to 'phase'. Should be 'str'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'phase'. Should be \'str\'", str(exp)) @pytest.mark.negative def test_MaterialStream_Z_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.Z = [] - self.assertIn("Incorrect type 'list' provided to 'Z'. Should be '('Dimensionless', 'int', 'float')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'Z'. Can be any one from '('Dimensionless', 'int', 'float')'", str(exp)) @pytest.mark.negative def test_MaterialStream_Z_g_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.Z_g = [] - self.assertIn("Incorrect type 'list' provided to 'Z_g'. Should be '('Dimensionless', 'int', 'float')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'Z_g'. Can be any one from '('Dimensionless', 'int', 'float')'", str(exp)) @pytest.mark.negative def test_MaterialStream_Z_l_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.Z_l = [] - self.assertIn("Incorrect type 'list' provided to 'Z_l'. Should be '('Dimensionless', 'int', 'float')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'Z_l'. Can be any one from '('Dimensionless', 'int', 'float')'", str(exp)) @pytest.mark.negative def test_MaterialStream_Pc_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.Pc = [] - self.assertIn("Incorrect type 'list' provided to 'Pc'. Should be '('Pressure', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'Pc'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.negative def test_MaterialStream_Psat_incorrect_type_to_value(self): with pytest.raises(Exception) as exp: m4 = MaterialStream() m4.Psat = [] - self.assertIn("Incorrect type 'list' provided to 'Psat'. Should be '('Pressure', 'int', 'float', 'tuple')'", str(exp)) + self.assertIn("Incorrect type 'list' provided to 'Psat'. Can be any one from '('Pressure', 'int', 'float', 'tuple')'", str(exp)) @pytest.mark.delete def test_MaterialStream_stream_equipment_delete_without_connection(self):