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

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_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_vmort.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.vmort import Vmort
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vmort import MockVmort
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_vmort():
+    m: MagicMock = mock_open(read_data="".join(MockVmort))
+    with patch("builtins.open", m):
+        n = Vmort.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] == 0.0
+        assert n.ree is not None
+        assert n.ree == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_vmort():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Vmort.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.ree is None
+
+
+def test_eq_vmort():
+    m: MagicMock = mock_open(read_data="".join(MockVmort))
+    with patch("builtins.open", m):
+        n1 = Vmort.read(ARQ_TESTE)
+        n2 = Vmort.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_vmortm.py

@@ -0,0 +1,40 @@
+from inewave.nwlistop.vmortm import Vmortm
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vmortm import MockVmortm
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_vmortm():
+    m: MagicMock = mock_open(read_data="".join(MockVmortm))
+    with patch("builtins.open", m):
+        n = Vmortm.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] == 0.0
+        assert n.submercado is not None
+        assert n.submercado == "SUDESTE"
+
+
+def test_atributos_nao_encontrados_vmortm():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Vmortm.read(ARQ_TESTE)
+        assert n.valores is None
+        assert n.submercado is None
+
+
+def test_eq_vmortm():
+    m: MagicMock = mock_open(read_data="".join(MockVmortm))
+    with patch("builtins.open", m):
+        n1 = Vmortm.read(ARQ_TESTE)
+        n2 = Vmortm.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_vmortsin.py

@@ -0,0 +1,37 @@
+from inewave.nwlistop.vmortsin import Vmortsin
+
+from datetime import datetime
+from tests.mocks.mock_open import mock_open
+from unittest.mock import MagicMock, patch
+
+from tests.mocks.arquivos.vmortsin import MockVmortsin
+
+ARQ_TESTE = "./tests/mocks/arquivos/__init__.py"
+
+
+def test_atributos_encontrados_vmortsin():
+    m: MagicMock = mock_open(read_data="".join(MockVmortsin))
+    with patch("builtins.open", m):
+        n = Vmortsin.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] == 0.0
+
+
+def test_atributos_nao_encontrados_vmortsin():
+    m: MagicMock = mock_open(read_data="")
+    with patch("builtins.open", m):
+        n = Vmortsin.read(ARQ_TESTE)
+        assert n.valores is None
+
+
+def test_eq_vmortsin():
+    m: MagicMock = mock_open(read_data="".join(MockVmortsin))
+    with patch("builtins.open", m):
+        n1 = Vmortsin.read(ARQ_TESTE)
+        n2 = Vmortsin.read(ARQ_TESTE)
+        assert n1 == n2
+
+
+# Não deve ter teste de diferença, visto que o atributo é
+# implementado como Lazy Property.