inewave 1.2.2__py3-none-any.whl → 1.4.0__py3-none-any.whl

tests/nwlistop/test_desvuh.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.desvuh import Desvuh
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.desvuh import MockDesvuh
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_desvuh():
+    m: MagicMock = mock_open(read_data="".join(MockDesvuh))
+    with patch("builtins.open", m):
+        n = Desvuh.read(ARQ_TESTE)
+        assert n.usina is not None
+        assert n.usina == "CAMARGOS"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2023, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.47
+
+
+def test_atributos_nao_encontrados_desvuh():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Desvuh.read(ARQ_TESTE)
+        assert n.usina is None
+        assert n.valores is None
+
+
+def test_eq_desvuh():
+    m: MagicMock = mock_open(read_data="".join(MockDesvuh))
+    with patch("builtins.open", m):
+        n1 = Desvuh.read(ARQ_TESTE)
+        n2 = Desvuh.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_edesvc.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.edesvc import Edesvc
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.edesvc import MockEdesvc
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_edesvc():
+    m: MagicMock = mock_open(read_data="".join(MockEdesvc))
+    with patch("builtins.open", m):
+        n = Edesvc.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == -145.0
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_edesvc():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Edesvc.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.ree is None
+
+
+def test_eq_edesvc():
+    m: MagicMock = mock_open(read_data="".join(MockEdesvc))
+    with patch("builtins.open", m):
+        n1 = Edesvc.read(ARQ_TESTE)
+        n2 = Edesvc.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_edesvcm.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.edesvcm import Edesvcm
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.edesvcm import MockEdesvcm
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_edesvcm():
+    m: MagicMock = mock_open(read_data="".join(MockEdesvcm))
+    with patch("builtins.open", m):
+        n = Edesvcm.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == -359.0
+        assert n.submercado is not None
+        assert n.submercado == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_edesvcm():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Edesvcm.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.submercado is None
+
+
+def test_eq_edesvcm():
+    m: MagicMock = mock_open(read_data="".join(MockEdesvcm))
+    with patch("builtins.open", m):
+        n1 = Edesvcm.read(ARQ_TESTE)
+        n2 = Edesvcm.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_edesvcsin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.edesvcsin import Edesvcsin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.edesvcsin import MockEdesvcsin
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_edesvcsin():
+    m: MagicMock = mock_open(read_data="".join(MockEdesvcsin))
+    with patch("builtins.open", m):
+        n = Edesvcsin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == -654.0
+
+
+def test_atributos_nao_encontrados_edesvcsin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Edesvcsin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_edesvcsin():
+    m: MagicMock = mock_open(read_data="".join(MockEdesvcsin))
+    with patch("builtins.open", m):
+        n1 = Edesvcsin.read(ARQ_TESTE)
+        n2 = Edesvcsin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_evapo.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.evapo import Evapo
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.evapo import MockEvapo
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_evapo():
+    m: MagicMock = mock_open(read_data="".join(MockEvapo))
+    with patch("builtins.open", m):
+        n = Evapo.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 20.0
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_evapo():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Evapo.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.ree is None
+
+
+def test_eq_evapo():
+    m: MagicMock = mock_open(read_data="".join(MockEvapo))
+    with patch("builtins.open", m):
+        n1 = Evapo.read(ARQ_TESTE)
+        n2 = Evapo.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_evapom.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.evapom import Evapom
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.evapom import MockEvapom
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_evapom():
+    m: MagicMock = mock_open(read_data="".join(MockEvapom))
+    with patch("builtins.open", m):
+        n = Evapom.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 266.0
+        assert n.submercado is not None
+        assert n.submercado == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_evapom():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Evapom.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.submercado is None
+
+
+def test_eq_evapom():
+    m: MagicMock = mock_open(read_data="".join(MockEvapom))
+    with patch("builtins.open", m):
+        n1 = Evapom.read(ARQ_TESTE)
+        n2 = Evapom.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_evaporsin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.evaporsin import Evaporsin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.evaporsin import MockEvaporsin
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_evaporsin():
+    m: MagicMock = mock_open(read_data="".join(MockEvaporsin))
+    with patch("builtins.open", m):
+        n = Evaporsin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 940.0
+
+
+def test_atributos_nao_encontrados_evaporsin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Evaporsin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_evaporsin():
+    m: MagicMock = mock_open(read_data="".join(MockEvaporsin))
+    with patch("builtins.open", m):
+        n1 = Evaporsin.read(ARQ_TESTE)
+        n2 = Evaporsin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_ghidr.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.ghidr import Ghidr
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.ghidr import MockGhidr
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_ghidr():
+    m: MagicMock = mock_open(read_data="".join(MockGhidr))
+    with patch("builtins.open", m):
+        n = Ghidr.read(ARQ_TESTE)
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 1113.5
+
+
+def test_atributos_nao_encontrados_ghidr():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Ghidr.read(ARQ_TESTE)
+        assert n.ree is None
+        assert n.valores is None
+
+
+def test_eq_ghidr():
+    m: MagicMock = mock_open(read_data="".join(MockGhidr))
+    with patch("builtins.open", m):
+        n1 = Ghidr.read(ARQ_TESTE)
+        n2 = Ghidr.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_ghidrm.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.ghidrm import Ghidrm
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.ghidrm import MockGhidrm
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_ghidrm():
+    m: MagicMock = mock_open(read_data="".join(MockGhidrm))
+    with patch("builtins.open", m):
+        n = Ghidrm.read(ARQ_TESTE)
+        assert n.submercado is not None
+        assert n.submercado == "SUDESTE"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 7177.5
+
+
+def test_atributos_nao_encontrados_ghidrm():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Ghidrm.read(ARQ_TESTE)
+        assert n.submercado is None
+        assert n.valores is None
+
+
+def test_eq_ghidrm():
+    m: MagicMock = mock_open(read_data="".join(MockGhidrm))
+    with patch("builtins.open", m):
+        n1 = Ghidrm.read(ARQ_TESTE)
+        n2 = Ghidrm.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_ghidrsin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.ghidrsin import Ghidrsin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.ghidrsin import MockGhidrsin
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_ghidrsin():
+    m: MagicMock = mock_open(read_data="".join(MockGhidrsin))
+    with patch("builtins.open", m):
+        n = Ghidrsin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 25070.1
+
+
+def test_atributos_nao_encontrados_ghidrsin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Ghidrsin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_ghidrsin():
+    m: MagicMock = mock_open(read_data="".join(MockGhidrsin))
+    with patch("builtins.open", m):
+        n1 = Ghidrsin.read(ARQ_TESTE)
+        n2 = Ghidrsin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_hjus.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.hjus import Hjus
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.hjus import MockHjus
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_hjus():
+    m: MagicMock = mock_open(read_data="".join(MockHjus))
+    with patch("builtins.open", m):
+        n = Hjus.read(ARQ_TESTE)
+        assert n.usina is not None
+        assert n.usina == "CAMARGOS"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2023, 1, 1)
+        assert n.valores.iloc[-1, -1] == 886.10
+
+
+def test_atributos_nao_encontrados_hjus():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Hjus.read(ARQ_TESTE)
+        assert n.usina is None
+        assert n.valores is None
+
+
+def test_eq_hjus():
+    m: MagicMock = mock_open(read_data="".join(MockHjus))
+    with patch("builtins.open", m):
+        n1 = Hjus.read(ARQ_TESTE)
+        n2 = Hjus.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_hliq.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.hliq import Hliq
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.hliq import MockHliq
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_hliq():
+    m: MagicMock = mock_open(read_data="".join(MockHliq))
+    with patch("builtins.open", m):
+        n = Hliq.read(ARQ_TESTE)
+        assert n.usina is not None
+        assert n.usina == "CAMARGOS"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2023, 1, 1)
+        assert n.valores.iloc[-1, -1] == 12.84
+
+
+def test_atributos_nao_encontrados_hliq():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Hliq.read(ARQ_TESTE)
+        assert n.usina is None
+        assert n.valores is None
+
+
+def test_eq_hliq():
+    m: MagicMock = mock_open(read_data="".join(MockHliq))
+    with patch("builtins.open", m):
+        n1 = Hliq.read(ARQ_TESTE)
+        n2 = Hliq.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_hmont.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.hmont import Hmont
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.hmont import MockHmont
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_hmont():
+    m: MagicMock = mock_open(read_data="".join(MockHmont))
+    with patch("builtins.open", m):
+        n = Hmont.read(ARQ_TESTE)
+        assert n.usina is not None
+        assert n.usina == "CAMARGOS"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2023, 1, 1)
+        assert n.valores.iloc[-1, -1] == 899.03
+
+
+def test_atributos_nao_encontrados_hmont():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Hmont.read(ARQ_TESTE)
+        assert n.usina is None
+        assert n.valores is None
+
+
+def test_eq_hmont():
+    m: MagicMock = mock_open(read_data="".join(MockHmont))
+    with patch("builtins.open", m):
+        n1 = Hmont.read(ARQ_TESTE)
+        n2 = Hmont.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_mevmin.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.mevmin import Mevmin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.mevmin import MockMevmin
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_mevmin():
+    m: MagicMock = mock_open(read_data="".join(MockMevmin))
+    with patch("builtins.open", m):
+        n = Mevmin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 1114.0
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_mevmin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Mevmin.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.ree is None
+
+
+def test_eq_mevmin():
+    m: MagicMock = mock_open(read_data="".join(MockMevmin))
+    with patch("builtins.open", m):
+        n1 = Mevmin.read(ARQ_TESTE)
+        n2 = Mevmin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_mevminm.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.mevminm import Mevminm
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.mevminm import MockMevminm
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_mevminm():
+    m: MagicMock = mock_open(read_data="".join(MockMevminm))
+    with patch("builtins.open", m):
+        n = Mevminm.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 6626.0
+        assert n.submercado is not None
+        assert n.submercado == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_mevminm():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Mevminm.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.submercado is None
+
+
+def test_eq_mevminm():
+    m: MagicMock = mock_open(read_data="".join(MockMevminm))
+    with patch("builtins.open", m):
+        n1 = Mevminm.read(ARQ_TESTE)
+        n2 = Mevminm.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_mevminsin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.mevminsin import Mevminsin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.mevminsin import MockMevminsin
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_mevminsin():
+    m: MagicMock = mock_open(read_data="".join(MockMevminsin))
+    with patch("builtins.open", m):
+        n = Mevminsin.read(ARQ_TESTE)
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2020, 1, 1)
+        assert n.valores.iloc[-1, -1] == 10991.0
+
+
+def test_atributos_nao_encontrados_mevminsin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Mevminsin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_mevminsin():
+    m: MagicMock = mock_open(read_data="".join(MockMevminsin))
+    with patch("builtins.open", m):
+        n1 = Mevminsin.read(ARQ_TESTE)
+        n2 = Mevminsin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.

tests/nwlistop/test_vdesviouh.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.vdesviouh import Vdesviouh
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vdesviouh import MockVdesviouh
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_vdesviouh():
+    m: MagicMock = mock_open(read_data="".join(MockVdesviouh))
+    with patch("builtins.open", m):
+        n = Vdesviouh.read(ARQ_TESTE)
+        assert n.usina is not None
+        assert n.usina == "CAMARGOS"
+        assert n.valores is not None
+        assert n.valores.iloc[0, 0] == datetime(2023, 1, 1)
+        assert n.valores.iloc[-1, -1] == 0.0
+
+
+def test_atributos_nao_encontrados_vdesviouh():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Vdesviouh.read(ARQ_TESTE)
+        assert n.usina is None
+        assert n.valores is None
+
+
+def test_eq_vdesviouh():
+    m: MagicMock = mock_open(read_data="".join(MockVdesviouh))
+    with patch("builtins.open", m):
+        n1 = Vdesviouh.read(ARQ_TESTE)
+        n2 = Vdesviouh.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.