Rename ApplicationCode to ApplicationLibCode

ApplicationLibCode/GrpcInterface/Python/rips/tests/conftest.py

@@ -0,0 +1,49 @@
+import pytest
+import sys
+import os
+import getopt
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+_rips_instance = None
+
+
+@pytest.fixture
+def rips_instance():
+    return _rips_instance
+
+
+@pytest.fixture
+def initialize_test():
+    _rips_instance.project.close()  # make sure ResInsight is clean before execution of test
+    yield initialize_test
+    _rips_instance.project.close()  # make sure ResInsight is clean after test
+
+
+def pytest_addoption(parser):
+    parser.addoption("--console", action="store_true", default=False,
+                     help="Run as console application")
+    parser.addoption("--existing", action="store_true", default=False,
+                     help="Look for existing ResInsight")
+
+
+def pytest_configure(config):
+    global _rips_instance
+    console = False
+    if config.getoption('--existing'):
+        print("Looking for existing ResInsight")
+        _rips_instance = rips.Instance.find()
+    else:
+        if config.getoption('--console'):
+            console = True
+        _rips_instance = rips.Instance.launch(console=console)
+    if not _rips_instance:
+        print("Need a valid ResInsight executable to launch tests")
+        exit(0)
+
+
+def pytest_unconfigure(config):
+    if not config.getoption('--existing'):
+        if _rips_instance:
+            _rips_instance.exit()

ApplicationLibCode/GrpcInterface/Python/rips/tests/dataroot.py

@@ -0,0 +1,3 @@
+# The path here is intended to be used when pytest is launced from the source tree of the ResInsight repository
+# This enables use of test datasets from the TestModels folder
+PATH = "../../../../TestModels"

ApplicationLibCode/GrpcInterface/Python/rips/tests/test_cases.py

@@ -0,0 +1,205 @@
+import sys
+import os
+import math
+import pytest
+import grpc
+import tempfile
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+import dataroot
+
+
+def test_Launch(rips_instance, initialize_test):
+    assert(rips_instance is not None)
+
+
+def test_EmptyProject(rips_instance, initialize_test):
+    cases = rips_instance.project.cases()
+    assert(len(cases) is 0)
+
+
+def test_OneCase(rips_instance, initialize_test):
+    case = rips_instance.project.load_case(
+        dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID")
+    assert(case.name == "TEST10K_FLT_LGR_NNC")
+    assert(case.id == 0)
+    cases = rips_instance.project.cases()
+    assert(len(cases) is 1)
+
+
+def test_BoundingBox(rips_instance, initialize_test):
+    case = rips_instance.project.load_case(
+        dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID")
+    assert(case.name == "TEST10K_FLT_LGR_NNC")
+    boundingbox = case.reservoir_boundingbox()
+    assert(math.isclose(3382.90, boundingbox.min_x, abs_tol=1.0e-1))
+    assert(math.isclose(5850.48, boundingbox.max_x, abs_tol=1.0e-1))
+    assert(math.isclose(4157.45, boundingbox.min_y, abs_tol=1.0e-1))
+    assert(math.isclose(7354.93, boundingbox.max_y, abs_tol=1.0e-1))
+    assert(math.isclose(-4252.61, boundingbox.min_z, abs_tol=1.0e-1))
+    assert(math.isclose(-4103.60, boundingbox.max_z, abs_tol=1.0e-1))
+
+    min_depth, max_depth = case.reservoir_depth_range()
+    assert(math.isclose(4103.60, min_depth, abs_tol=1.0e-1))
+    assert(math.isclose(4252.61, max_depth, abs_tol=1.0e-1))
+
+
+def test_MultipleCases(rips_instance, initialize_test):
+    case_paths = []
+    case_paths.append(dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID")
+    case_paths.append(dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID")
+    case_paths.append(dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID")
+
+    case_names = []
+    for case_path in case_paths:
+        case_name = os.path.splitext(os.path.basename(case_path))[0]
+        case_names.append(case_name)
+        rips_instance.project.load_case(path=case_path)
+
+    cases = rips_instance.project.cases()
+    assert(len(cases) == len(case_names))
+    for i, case_name in enumerate(case_names):
+        assert(case_name == cases[i].name)
+
+
+def get_cell_index_with_ijk(cell_info, i, j, k):
+    for (idx, cell) in enumerate(cell_info):
+        if cell.local_ijk.i == i and cell.local_ijk.j == j and cell.local_ijk.k == k:
+            return idx
+    return -1
+
+
+def check_corner(actual, expected):
+    assert(math.isclose(actual.x, expected[0], abs_tol=0.1))
+    assert(math.isclose(actual.y, expected[1], abs_tol=0.1))
+    assert(math.isclose(actual.z, expected[2], abs_tol=0.1))
+
+
+def test_10k(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=case_path)
+    assert(len(case.grids()) == 2)
+    cell_count_info = case.cell_count()
+    assert(cell_count_info.active_cell_count == 11125)
+    assert(cell_count_info.reservoir_cell_count == 316224)
+    time_steps = case.time_steps()
+    assert(len(time_steps) == 9)
+    days_since_start = case.days_since_start()
+    assert(len(days_since_start) == 9)
+    cell_info = case.cell_info_for_active_cells()
+    assert(len(cell_info) == cell_count_info.active_cell_count)
+
+    # Check an active cell (found in resinsight ui)
+    cell_index = get_cell_index_with_ijk(cell_info, 23, 44, 19)
+    assert(cell_index != -1)
+
+    cell_centers = case.active_cell_centers()
+    assert(len(cell_centers) == cell_count_info.active_cell_count)
+
+    # Check the cell center for the specific cell
+    assert(math.isclose(3627.17, cell_centers[cell_index].x, abs_tol=0.1))
+    assert(math.isclose(5209.75, cell_centers[cell_index].y, abs_tol=0.1))
+    assert(math.isclose(4179.6, cell_centers[cell_index].z, abs_tol=0.1))
+
+    cell_corners = case.active_cell_corners()
+    assert(len(cell_corners) == cell_count_info.active_cell_count)
+    # Expected values from ResInsight UI
+    expected_corners = [[3565.22, 5179.02, 4177.18],
+                        [3655.67, 5145.34, 4176.63],
+                        [3690.07, 5240.69, 4180.02],
+                        [3599.87, 5275.16, 4179.32],
+                        [3564.13, 5178.61, 4179.75],
+                        [3654.78, 5144.79, 4179.23],
+                        [3688.99, 5239.88, 4182.7],
+                        [3598.62, 5274.48, 4181.96]]
+    check_corner(cell_corners[cell_index].c0, expected_corners[0])
+    check_corner(cell_corners[cell_index].c1, expected_corners[1])
+    check_corner(cell_corners[cell_index].c2, expected_corners[2])
+    check_corner(cell_corners[cell_index].c3, expected_corners[3])
+    check_corner(cell_corners[cell_index].c4, expected_corners[4])
+    check_corner(cell_corners[cell_index].c5, expected_corners[5])
+    check_corner(cell_corners[cell_index].c6, expected_corners[6])
+    check_corner(cell_corners[cell_index].c7, expected_corners[7])
+
+    # No coarsening info for this case
+    coarsening_info = case.coarsening_info()
+    assert(len(coarsening_info) == 0)
+
+
+def test_PdmObject(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=case_path)
+    assert(case.id == 0)
+    assert(case.address() is not 0)
+    assert(case.__class__.__name__ == "EclipseCase")
+
+
+@pytest.mark.skipif(sys.platform.startswith('linux'), reason="Brugge is currently exceptionally slow on Linux")
+def test_brugge_0010(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/Case_with_10_timesteps/Real10/BRUGGE_0010.EGRID"
+    case = rips_instance.project.load_case(path=case_path)
+    assert(len(case.grids()) == 1)
+    cellCountInfo = case.cell_count()
+    assert(cellCountInfo.active_cell_count == 43374)
+    assert(cellCountInfo.reservoir_cell_count == 60048)
+    time_steps = case.time_steps()
+    assert(len(time_steps) == 11)
+    days_since_start = case.days_since_start()
+    assert(len(days_since_start) == 11)
+
+
+@pytest.mark.skipif(sys.platform.startswith('linux'), reason="Brugge is currently exceptionally slow on Linux")
+def test_replaceCase(rips_instance, initialize_test):
+    project = rips_instance.project.open(dataroot.PATH + "/TEST10K_FLT_LGR_NNC/10KWithWellLog.rsp")
+    case_path = dataroot.PATH + "/Case_with_10_timesteps/Real0/BRUGGE_0000.EGRID"
+    case = project.case(case_id=0)
+    assert(case is not None)
+    assert(case.name == "TEST10K_FLT_LGR_NNC")
+    assert(case.id == 0)
+    cases = rips_instance.project.cases()
+    assert(len(cases) is 1)
+
+    case.replace(new_grid_file=case_path)
+    # Check that the case object has been changed
+    assert(case.name == "BRUGGE_0000")
+    assert(case.id == 0)
+
+    cases = rips_instance.project.cases()
+    assert(len(cases) is 1)
+    # Check that retrieving the case object again will yield the changed object
+    case = project.case(case_id=0)
+    assert(case.name == "BRUGGE_0000")
+    assert(case.id == 0)
+
+
+def test_loadNonExistingCase(rips_instance, initialize_test):
+    case_path = "Nonsense/Nonsense/Nonsense"
+    with pytest.raises(grpc.RpcError):
+        assert rips_instance.project.load_case(case_path)
+
+
+@pytest.mark.skipif(sys.platform.startswith('linux'), reason="Brugge is currently exceptionally slow on Linux")
+def test_exportFlowCharacteristics(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/Case_with_10_timesteps/Real0/BRUGGE_0000.EGRID"
+    case = rips_instance.project.load_case(case_path)
+    with tempfile.TemporaryDirectory(prefix="rips") as tmpdirname:
+        print("Temporary folder: ", tmpdirname)
+        file_name = tmpdirname + "/exportFlowChar.txt"
+        case.export_flow_characteristics(time_steps=8, producers=[],
+                                         injectors="I01", file_name=file_name)
+
+
+def test_selected_cells(rips_instance, initialize_test):
+    case = rips_instance.project.load_case(
+        dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID")
+    assert(case.name == "TEST10K_FLT_LGR_NNC")
+    selected_cells = case.selected_cells()
+    assert(len(selected_cells) == 0)
+
+    time_step_info = case.time_steps()
+    for (tidx, timestep) in enumerate(time_step_info):
+        # Try to read for SOIL the time step (will be empty since nothing is selected)
+        soil_results = case.selected_cell_property('DYNAMIC_NATIVE', 'SOIL', tidx)
+        assert(len(soil_results) == 0)

ApplicationLibCode/GrpcInterface/Python/rips/tests/test_commands.py

@@ -0,0 +1,10 @@
+import sys
+import os
+import tempfile
+import pytest
+import grpc
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+import dataroot

ApplicationLibCode/GrpcInterface/Python/rips/tests/test_grids.py

@@ -0,0 +1,55 @@
+import sys
+import os
+import math
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+import dataroot
+
+
+def check_corner(actual, expected):
+    assert(math.isclose(actual.x, expected[0], abs_tol=0.1))
+    assert(math.isclose(actual.y, expected[1], abs_tol=0.1))
+    assert(math.isclose(actual.z, expected[2], abs_tol=0.1))
+
+
+def test_10k(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+    assert(len(case.grids()) == 2)
+    grid = case.grid(index=0)
+    dimensions = grid.dimensions()
+    assert(dimensions.i == 90)
+    assert(dimensions.j == 96)
+    assert(dimensions.k == 36)
+
+    cell_centers = grid.cell_centers()
+    assert(len(cell_centers) == (dimensions.i * dimensions.j * dimensions.k))
+
+    # Test a specific cell (results from ResInsight UI)
+    cell_index = 168143
+    assert(math.isclose(3627.17, cell_centers[cell_index].x, abs_tol=0.1))
+    assert(math.isclose(5209.75, cell_centers[cell_index].y, abs_tol=0.1))
+    assert(math.isclose(4179.6, cell_centers[cell_index].z, abs_tol=0.1))
+
+    cell_corners = grid.cell_corners()
+    assert(len(cell_corners) == (dimensions.i * dimensions.j * dimensions.k))
+
+    # Expected values from ResInsight UI
+    expected_corners = [[3565.22, 5179.02, 4177.18],
+                        [3655.67, 5145.34, 4176.63],
+                        [3690.07, 5240.69, 4180.02],
+                        [3599.87, 5275.16, 4179.32],
+                        [3564.13, 5178.61, 4179.75],
+                        [3654.78, 5144.79, 4179.23],
+                        [3688.99, 5239.88, 4182.7],
+                        [3598.62, 5274.48, 4181.96]]
+    check_corner(cell_corners[cell_index].c0, expected_corners[0])
+    check_corner(cell_corners[cell_index].c1, expected_corners[1])
+    check_corner(cell_corners[cell_index].c2, expected_corners[2])
+    check_corner(cell_corners[cell_index].c3, expected_corners[3])
+    check_corner(cell_corners[cell_index].c4, expected_corners[4])
+    check_corner(cell_corners[cell_index].c5, expected_corners[5])
+    check_corner(cell_corners[cell_index].c6, expected_corners[6])
+    check_corner(cell_corners[cell_index].c7, expected_corners[7])

ApplicationLibCode/GrpcInterface/Python/rips/tests/test_nnc_properties.py

@@ -0,0 +1,74 @@
+import sys
+import os
+import grpc
+import pytest
+
+import rips.generated.NNCProperties_pb2 as NNCProperties_pb2
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+import dataroot
+
+
+def test_10kSync(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    properties = case.available_nnc_properties()
+    assert(len(properties) == 1)
+
+    assert("TRAN" == properties[0].name)
+    assert(NNCProperties_pb2.NNCPropertyType.Value('NNC_STATIC') == properties[0].property_type)
+
+    nnc_connections = case.nnc_connections()
+    assert(len(nnc_connections) == 3627)
+
+    connection = nnc_connections[0]
+    assert(connection.cell1.i == 33)
+    assert(connection.cell1.j == 40)
+    assert(connection.cell1.k == 14)
+    assert(connection.cell_grid_index1 == 0)
+
+    tran_vals = case.nnc_connections_static_values("TRAN")
+    assert(len(tran_vals) == len(nnc_connections))
+
+    for t in tran_vals:
+        assert(isinstance(t, float))
+
+    # Generate some data
+    new_data = []
+    for (c, _) in enumerate(nnc_connections):
+        new_data.append(float(c))
+
+    property_name = "NEW_PROP"
+    case.set_nnc_connections_values(new_data, property_name, 0)
+    new_prop_vals = case.nnc_connections_generated_values(property_name, 0)
+    assert(len(new_prop_vals) == len(new_data))
+    for i in range(0, len(new_data)):
+        assert(new_data[i] == new_prop_vals[i])
+
+    # Set some other data for second time step
+    for i in range(0, len(new_data)):
+        new_data[i] = new_data[i] * 2.0
+
+    case.set_nnc_connections_values(new_data, property_name, 1)
+    new_prop_vals = case.nnc_connections_generated_values(property_name, 1)
+    assert(len(new_prop_vals) == len(nnc_connections))
+    for i in range(0, len(new_data)):
+        assert(new_data[i] == new_prop_vals[i])
+
+
+def test_non_existing_dynamic_values(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    with pytest.raises(grpc.RpcError):
+        case.nnc_connections_dynamic_values("x", 0)
+
+
+def test_invalid_time_steps(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+    with pytest.raises(grpc.RpcError):
+        case.nnc_connections_generated_values("Formation Allan", 9999)

ApplicationLibCode/GrpcInterface/Python/rips/tests/test_project.py

@@ -0,0 +1,75 @@
+import sys
+import os
+import pytest
+import grpc
+import tempfile
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+import dataroot
+
+
+def test_loadProject(rips_instance, initialize_test):
+    project = rips_instance.project.open(dataroot.PATH + "/TEST10K_FLT_LGR_NNC/10KWithWellLog.rsp")
+    case = project.cases()[0]
+    assert(case is not None)
+    assert(case.name == "TEST10K_FLT_LGR_NNC")
+    assert(case.id == 0)
+    cases = rips_instance.project.cases()
+    assert(len(cases) is 1)
+
+
+def test_well_log_plots(rips_instance, initialize_test):
+    project = rips_instance.project.open(dataroot.PATH + "/TEST10K_FLT_LGR_NNC/10KWithWellLog.rsp")
+    plots = project.plots()
+    well_log_plots = []
+    for plot in plots:
+        if isinstance(plot, rips.WellLogPlot):
+            assert(plot.depth_type == "MEASURED_DEPTH")
+            well_log_plots.append(plot)
+    assert(len(well_log_plots) == 2)
+
+    with tempfile.TemporaryDirectory(prefix="rips") as tmpdirname:
+        for well_log_plot in well_log_plots:
+            well_log_plot.depth_type = "TRUE_VERTICAL_DEPTH_RKB"
+            well_log_plot.update()
+            if rips_instance.is_gui():
+                well_log_plot.export_snapshot(tmpdirname)
+            well_log_plot.export_data_as_las(tmpdirname)
+        files = os.listdir(tmpdirname)
+        print(files)
+        if rips_instance.is_gui():
+            assert(len(files) == 4)
+        else:
+            assert(len(files) == 2)
+
+    plots2 = project.plots()
+    for plot2 in plots2:
+        if isinstance(plot2, rips.WellLogPlot):
+            assert(plot2.depth_type == "TRUE_VERTICAL_DEPTH_RKB")
+
+
+@pytest.mark.skipif(sys.platform.startswith('linux'), reason="Brugge is currently exceptionally slow on Linux")
+def test_loadGridCaseGroup(rips_instance, initialize_test):
+    case_paths = []
+    case_paths.append(dataroot.PATH + "/Case_with_10_timesteps/Real0/BRUGGE_0000.EGRID")
+    case_paths.append(dataroot.PATH + "/Case_with_10_timesteps/Real10/BRUGGE_0010.EGRID")
+    grid_case_group = rips_instance.project.create_grid_case_group(case_paths=case_paths)
+    assert(grid_case_group is not None and grid_case_group.group_id == 0)
+
+
+def test_exportSnapshots(rips_instance, initialize_test):
+    if not rips_instance.is_gui():
+        pytest.skip("Cannot run test without a GUI")
+
+    case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    rips_instance.project.load_case(case_path)
+    with tempfile.TemporaryDirectory(prefix="rips") as tmpdirname:
+        print("Temporary folder: ", tmpdirname)
+        rips_instance.set_export_folder(export_type='SNAPSHOTS', path=tmpdirname)
+        rips_instance.project.export_snapshots()
+        print(os.listdir(tmpdirname))
+#        assert(len(os.listdir(tmpdirname)) > 0)
+        for fileName in os.listdir(tmpdirname):
+            assert(os.path.splitext(fileName)[1] == '.png')

ApplicationLibCode/GrpcInterface/Python/rips/tests/test_properties.py

@@ -0,0 +1,112 @@
+import sys
+import os
+import grpc
+import pytest
+import tempfile
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+import dataroot
+
+
+def test_10kAsync(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    resultChunks = case.active_cell_property_async('DYNAMIC_NATIVE', 'SOIL', 1)
+    mysum = 0.0
+    count = 0
+    for chunk in resultChunks:
+        mysum += sum(chunk.values)
+        count += len(chunk.values)
+    average = mysum / count
+    assert(mysum == pytest.approx(621.768, abs=0.001))
+    assert(average != pytest.approx(0.0158893, abs=0.0000001))
+    assert(average == pytest.approx(0.0558893, abs=0.0000001))
+
+
+def test_10kSync(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    results = case.active_cell_property('DYNAMIC_NATIVE', 'SOIL', 1)
+    mysum = sum(results)
+    average = mysum / len(results)
+    assert(mysum == pytest.approx(621.768, abs=0.001))
+    assert(average != pytest.approx(0.0158893, abs=0.0000001))
+    assert(average == pytest.approx(0.0558893, abs=0.0000001))
+
+
+def test_10k_set(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    results = case.active_cell_property('DYNAMIC_NATIVE', 'SOIL', 1)
+    case.set_active_cell_property(results, 'GENERATED', 'SOIL', 1)
+
+
+def test_10k_set_out_of_bounds(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    results = case.active_cell_property('DYNAMIC_NATIVE', 'SOIL', 1)
+    results.append(5.0)
+    with pytest.raises(grpc.RpcError):
+        assert case.set_active_cell_property(results, 'GENERATED', 'SOIL', 1)
+
+
+def test_10k_set_out_of_bounds_client(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    results = case.active_cell_property('DYNAMIC_NATIVE', 'SOIL', 1)
+    case.chunk_size = len(results)
+    results.append(5.0)
+    with pytest.raises(IndexError):
+        assert case.set_active_cell_property(results, 'GENERATED', 'SOIL', 1)
+
+
+def createResult(poroChunks, permxChunks):
+    for (poroChunk, permxChunk) in zip(poroChunks, permxChunks):
+        resultChunk = []
+        for (poro, permx) in zip(poroChunk.values, permxChunk.values):
+            resultChunk.append(poro * permx)
+        yield resultChunk
+
+
+def checkResults(poroValues, permxValues, poropermxValues):
+    for (poro, permx, poropermx) in zip(poroValues, permxValues, poropermxValues):
+        recalc = poro * permx
+        assert(recalc == pytest.approx(poropermx, rel=1.0e-10))
+
+
+def test_10k_PoroPermX(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=casePath)
+
+    poroChunks = case.active_cell_property_async('STATIC_NATIVE', 'PORO', 0)
+    permxChunks = case.active_cell_property_async('STATIC_NATIVE', 'PERMX', 0)
+
+    case.set_active_cell_property_async(createResult(
+        poroChunks, permxChunks), 'GENERATED', 'POROPERMXAS', 0)
+
+    poro = case.active_cell_property('STATIC_NATIVE', 'PORO', 0)
+    permx = case.active_cell_property('STATIC_NATIVE', 'PERMX', 0)
+    poroPermX = case.active_cell_property('GENERATED', 'POROPERMXAS', 0)
+
+    checkResults(poro, permx, poroPermX)
+
+
+def test_exportPropertyInView(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    rips_instance.project.load_case(case_path)
+    with tempfile.TemporaryDirectory(prefix="rips") as tmpdirname:
+        print("Temporary folder: ", tmpdirname)
+        rips_instance.set_export_folder(export_type='PROPERTIES', path=tmpdirname)
+        case = rips_instance.project.cases()[0]
+        view = case.views()[0]
+        view.export_property()
+        expected_file_name = case.name + "-" + str("3D_View") + "-" + "T0" + "-SOIL"
+        full_path = tmpdirname + "/" + expected_file_name
+        assert(os.path.exists(full_path))

ApplicationLibCode/GrpcInterface/Python/rips/tests/test_simulation_wells.py

@@ -0,0 +1,51 @@
+import sys
+import os
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+import dataroot
+
+
+def test_10k(rips_instance, initialize_test):
+    case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=case_path)
+    assert(len(case.grids()) == 2)
+    cell_count_info = case.cell_count()
+
+    sim_wells = case.simulation_wells()
+    assert(len(sim_wells) == 3)
+
+    assert(sim_wells[0].name == "GI1")
+    assert(sim_wells[1].name == "GP1")
+    assert(sim_wells[2].name == "GP2")
+
+    timesteps = case.time_steps()
+
+    # On time step 0 all simulation wells are undefined
+    for sim_well in sim_wells:
+        status = sim_well.status(0)
+        assert(status.well_type == "NotDefined")
+
+    # On time step 3 all wells are producing
+    for sim_well in sim_wells:
+        status = sim_well.status(3)
+        assert(status.well_type == "Producer")
+
+    # On time step 0 all simulation wells have no cells
+    for sim_well in sim_wells:
+        cells = sim_well.cells(0)
+        assert(len(cells) == 0)
+
+    # On the other time steps there should be cells
+    expected_cell_count = {}
+    expected_cell_count["GP1"] = 105
+    expected_cell_count["GI1"] = 38
+    expected_cell_count["GP2"] = 18
+    for sim_well in sim_wells:
+        for (tidx, timestep) in enumerate(timesteps):
+            if (tidx > 0):
+                cells = sim_well.cells(tidx)
+                print("well: " + sim_well.name + " timestep: " +
+                      str(tidx) + " cells:" + str(len(cells)))
+                assert(len(cells) == expected_cell_count[sim_well.name])

ApplicationLibCode/GrpcInterface/Python/rips/tests/test_summary_cases.py

@@ -0,0 +1,115 @@
+import sys
+import os
+import math
+import contextlib
+import os
+import shutil
+import tempfile
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+import dataroot
+
+
+def test_summary_import_and_find(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/flow_diagnostics_test/SIMPLE_SUMMARY2.SMSPEC"
+    summary_case = rips_instance.project.import_summary_case(casePath)
+    assert(summary_case.id == 1)
+
+    case_id = 234
+    found_summary_case = rips_instance.project.summary_case(case_id)
+    assert(found_summary_case is None)
+
+    correct_case_id = 1
+    found_summary_case = rips_instance.project.summary_case(correct_case_id)
+    assert(found_summary_case is not None)
+
+    rips_instance.project.close()
+    correct_case_id = 1
+    found_summary_case = rips_instance.project.summary_case(correct_case_id)
+    assert(found_summary_case is None)
+
+
+def test_summary_data(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/flow_diagnostics_test/SIMPLE_SUMMARY2.SMSPEC"
+    summary_case = rips_instance.project.import_summary_case(casePath)
+    assert(summary_case.id == 1)
+
+    addresses = summary_case.available_addresses()
+    assert(len(addresses.values) == 343)
+
+    summary_data = summary_case.summary_vector_values("FOPT")
+    assert(len(summary_data.values) == 60)
+
+
+def test_summary_resample(rips_instance, initialize_test):
+    casePath = dataroot.PATH + "/flow_diagnostics_test/SIMPLE_SUMMARY2.SMSPEC"
+    summary_case = rips_instance.project.import_summary_case(casePath)
+    assert(summary_case.id == 1)
+
+    summary_data_sampled = summary_case.resample_values("FOPT", "NONE")
+    assert(len(summary_data_sampled.values) == 60)
+    assert(len(summary_data_sampled.time_steps) == 60)
+
+    summary_data_sampled = summary_case.resample_values("FOPT", "DAY")
+    assert(len(summary_data_sampled.values) == 721)
+    assert(len(summary_data_sampled.time_steps) == 721)
+
+    summary_data_sampled = summary_case.resample_values("FOPT", "MONTH")
+    assert(len(summary_data_sampled.values) == 24)
+    assert(len(summary_data_sampled.time_steps) == 24)
+
+    summary_data_sampled = summary_case.resample_values("FOPT", "QUARTER")
+    assert(len(summary_data_sampled.values) == 8)
+    assert(len(summary_data_sampled.time_steps) == 8)
+
+    summary_data_sampled = summary_case.resample_values("FOPT", "YEAR")
+    assert(len(summary_data_sampled.values) == 3)
+    assert(len(summary_data_sampled.time_steps) == 3)
+
+
+@contextlib.contextmanager
+def cd(newdir, cleanup=lambda: True):
+    prevdir = os.getcwd()
+    os.chdir(os.path.expanduser(newdir))
+    try:
+        yield
+    finally:
+        os.chdir(prevdir)
+        cleanup()
+
+@contextlib.contextmanager
+def tempdir():
+    dirpath = tempfile.mkdtemp()
+    def cleanup():
+        shutil.rmtree(dirpath)
+    with cd(dirpath, cleanup):
+        yield dirpath
+
+# This test ensures that missing unsmry file is handeled gracefully
+def test_summary_no_unsmry(rips_instance, initialize_test):
+    casePathRelative = dataroot.PATH + "/flow_diagnostics_test/SIMPLE_SUMMARY2.SMSPEC"
+
+    # create an absolute path, as the helper functions used to create a temporary folder does not work
+    # with the relative (..\..\) part of the file path
+    casePath = os.path.abspath(casePathRelative)
+
+    with tempdir() as dirpath:
+        base_path = os.path.basename(casePath)
+        temp_path = os.path.join(dirpath, base_path)
+        shutil.copy2(casePath, temp_path)
+
+        summary_case = rips_instance.project.import_summary_case(temp_path)
+
+        values = summary_case.summary_vector_values()
+        assert(len(values.values) == 1)
+
+        time_steps = summary_case.available_time_steps()
+        assert(len(time_steps.values) == 1)
+
+        addresses = summary_case.available_addresses()
+        assert(len(addresses.values) == 1)
+
+        summary_case.resample_values()
+

ApplicationLibCode/GrpcInterface/Python/rips/tests/test_wells.py

@@ -0,0 +1,20 @@
+import sys
+import os
+
+sys.path.insert(1, os.path.join(sys.path[0], '../../'))
+import rips
+
+import dataroot
+
+
+def test_10k(rips_instance, initialize_test):
+    case_root_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC"
+    case_path = case_root_path + "/TEST10K_FLT_LGR_NNC.EGRID"
+    case = rips_instance.project.load_case(path=case_path)
+    assert(len(case.grids()) == 2)
+    well_path_files = [case_root_path + "/wellpath_a.dev", case_root_path + "/wellpath_b.dev"]
+    well_path_names = rips_instance.project.import_well_paths(well_path_files)
+    wells = rips_instance.project.well_paths()
+    assert(len(wells) == 2)
+    assert(wells[0].name == "Well Path A")
+    assert(wells[1].name == "Well Path B")