Merge pull request #35 from jinningwang/cov

Improve coverage

tests/test_andes.py

@@ -0,0 +1,92 @@
+"""
+Test ANDES interface.
+"""
+
+import unittest
+import numpy as np
+
+import andes
+import ams
+
+from ams.interop.andes import build_group_table, to_andes, parse_addfile
+
+
+class TestInteropBase(unittest.TestCase):
+    """
+    Tests for basic function of ANDES interface.
+
+    # TODO: add case that involve PVD1 or REGCV1
+    """
+    ad_cases = [
+        'ieee14/ieee14_full.xlsx',
+        'ieee39/ieee39_full.xlsx',
+    ]
+    am_cases = [
+        'ieee14/ieee14.json',
+        'ieee39/ieee39.xlsx',
+    ]
+
+    def setUp(self) -> None:
+        """
+        Test setup.
+        """
+
+    def test_build_group_table(self):
+        for ad_case in self.ad_cases:
+            sa = andes.load(andes.get_case(ad_case),
+                            setup=True,
+                            no_output=True,
+                            default_config=True,)
+            ssa_stg = build_group_table(adsys=sa,
+                                        grp_name='StaticGen',
+                                        param_name=['u', 'name', 'idx', 'bus'],
+                                        mdl_name=[])
+            self.assertEqual(ssa_stg.shape,
+                             (sa.StaticGen.n, 4))
+
+            ssa_gov = build_group_table(adsys=sa, grp_name='TurbineGov',
+                                        param_name=['idx', 'syn'],
+                                        mdl_name=[])
+            self.assertEqual(ssa_gov.shape,
+                             (sa.TurbineGov.n, 2))
+
+    def test_convert(self):
+        for ad_case, am_case in zip(self.ad_cases, self.am_cases):
+            sp = ams.load(ams.get_case(am_case),
+                          setup=True,
+                          no_output=True,
+                          default_config=True,)
+            # before addfile
+            sa = to_andes(sp, setup=False)
+            self.assertEqual(set(sp.PV.idx.v), set(sa.PV.idx.v))
+            self.assertEqual(set(sp.Bus.idx.v), set(sa.Bus.idx.v))
+            self.assertEqual(set(sp.Line.idx.v), set(sa.Line.idx.v))
+            self.assertEqual(np.sum(sp.PQ.p0.v), np.sum(sa.PQ.p0.v))
+
+            # after addfile
+            sa = parse_addfile(adsys=sa, amsys=sp,
+                               addfile=andes.get_case(ad_case))
+            sa.setup()
+            set1 = set(sa.GENROU.gen.v)
+            set2 = set(sp.StaticGen.get_idx())
+            # set2 includes set1, ensure GENROU.gen are all in StaticGen.idx
+            self.assertEqual(set1, set1 & set2)
+
+
+class TestANDES(unittest.TestCase):
+    """
+    Tests for ANDES interface.
+
+    # TODO: add tests for ANDES interface functions.
+    """
+    cases = [
+        '5bus/pjm5bus_demo.xlsx',
+        'ieee14/ieee14_uced.xlsx',
+        'ieee39/ieee39_uced_esd1.xlsx',
+        'matpower/case118.m',
+    ]
+
+    def setUp(self) -> None:
+        """
+        Test setup. This is executed before each test case.
+        """

tests/test_export_csv.py

@@ -0,0 +1,85 @@
+"""
+Test routine export to CSV.
+"""
+import unittest
+import os
+import csv
+
+import numpy as np
+
+import ams
+
+
+class TestExportCSV(unittest.TestCase):
+    """
+    Tests for Routine export to CSV.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.main.load(
+            ams.get_case("5bus/pjm5bus_demo.xlsx"),
+            default_config=True,
+            no_output=True,
+        )
+        self.expected_csv_DCOPF = 'pjm5bus_demo_DCOPF.csv'
+        self.expected_csv_ED = 'pjm5bus_demo_ED.csv'
+
+    def test_no_export(self):
+        """
+        Test no export when routine is not converged.
+        """
+        self.assertIsNone(self.ss.DCOPF.export_csv())
+
+    def test_export_DCOPF(self):
+        """
+        Test export DCOPF to CSV.
+        """
+        self.ss.DCOPF.run(solver='ECOS')
+        self.assertTrue(self.ss.DCOPF.export_csv())
+        self.assertTrue(os.path.exists(self.expected_csv_DCOPF))
+
+        n_rows = 0
+        n_cols = 0
+        with open(self.expected_csv_DCOPF, 'r') as csv_file:
+            csv_reader = csv.reader(csv_file)
+            for row in csv_reader:
+                n_rows += 1
+                # Check if this row has more columns than the previous rows
+                if n_cols == 0 or len(row) > n_cols:
+                    n_cols = len(row)
+
+        n_cols_expected = np.sum([v.shape[0] for v in self.ss.DCOPF.vars.values()])
+        # cols number plus one for the index column
+        self.assertEqual(n_cols, n_cols_expected + 1)
+        # header row plus data row
+        n_rows_expected = 2
+        self.assertEqual(n_rows, n_rows_expected)
+
+        os.remove(self.expected_csv_DCOPF)
+
+    def test_export_ED(self):
+        """
+        Test export ED to CSV.
+        """
+        self.ss.ED.run(solver='ECOS')
+        self.assertTrue(self.ss.ED.export_csv())
+        self.assertTrue(os.path.exists(self.expected_csv_ED))
+
+        n_rows = 0
+        n_cols = 0
+        with open(self.expected_csv_ED, 'r') as csv_file:
+            csv_reader = csv.reader(csv_file)
+            for row in csv_reader:
+                n_rows += 1
+                # Check if this row has more columns than the previous rows
+                if n_cols == 0 or len(row) > n_cols:
+                    n_cols = len(row)
+
+        n_cols_expected = np.sum([v.shape[0] for v in self.ss.ED.vars.values()])
+        # cols number plus one for the index column
+        self.assertEqual(n_cols, n_cols_expected + 1)
+        # header row plus data row
+        n_rows_expected = len(self.ss.ED.timeslot.v) + 1
+        self.assertTrue(n_rows, n_rows_expected)
+
+        os.remove(self.expected_csv_ED)

tests/test_known_good.py

@@ -0,0 +1,23 @@
+import logging
+import unittest
+
+import ams
+
+logger = logging.getLogger(__name__)
+
+
+class TestKnownResults(unittest.TestCase):
+    # NOTE: DCOPF objective values are from MATPOWER v8.0b1
+    sets = (
+        (ams.get_case('matpower/case14.m'), 7642.59177699),
+        (ams.get_case('matpower/case39.m'), 41263.94078588),
+        (ams.get_case('matpower/case118.m'), 125947.8814179),
+    )
+
+    def test_known_results(self):
+        for case, obj in self.sets:
+            sp = ams.load(case, setup=True, no_output=True)
+            sp.DCOPF.run(solver='ECOS')
+            msg = f'Case: {case}; Result: {sp.DCOPF.obj.v}; Expected: {obj}'
+            logger.info(msg)
+            self.assertAlmostEqual(sp.DCOPF.obj.v, obj, places=2)

tests/test_report.py

@@ -0,0 +1,76 @@
+"""
+Test system report.
+"""
+import unittest
+import os
+
+import ams
+
+
+class TestReport(unittest.TestCase):
+    """
+    Tests for Report class.
+    """
+
+    def setUp(self) -> None:
+        self.ss = ams.main.load(
+            ams.get_case("5bus/pjm5bus_demo.xlsx"),
+            default_config=True,
+            no_output=True,
+        )
+        self.expected_report = 'pjm5bus_demo_out.txt'
+
+    def test_no_output(self):
+        """
+        Test no output.
+        """
+        self.assertTrue(self.ss.files.no_output)
+        self.assertFalse(self.ss.report())
+
+    def test_no_report(self):
+        """
+        Test report with no solved routine.
+        """
+        self.ss.files.no_output = False
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertNotIn("DCOPF", file_contents)
+
+        os.remove(self.expected_report)
+
+    def test_DCOPF_report(self):
+        """
+        Test report with DCOPF solved.
+        """
+        self.ss.files.no_output = False
+        self.ss.DCOPF.run(solver='ECOS')
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("DCOPF", file_contents)
+
+        os.remove(self.expected_report)
+
+    def test_multi_report(self):
+        """
+        Test report with multiple solved routines.
+        """
+        self.ss.files.no_output = False
+        self.ss.DCOPF.run(solver='ECOS')
+        self.ss.RTED.run(solver='ECOS')
+        self.ss.ED.run(solver='ECOS')
+        self.assertTrue(self.ss.report())
+        self.assertTrue(os.path.exists(self.expected_report))
+
+        with open(self.expected_report, "r") as report_file:
+            file_contents = report_file.read()
+            self.assertIn("DCOPF", file_contents)
+            self.assertIn("RTED", file_contents)
+            self.assertIn("ED", file_contents)
+
+        os.remove(self.expected_report)