Merge pull request #18 from BritishGeologicalSurvey/test-cli

Test CLI

Author: volcan01010

.github/workflows/ci.yml

@@ -19,8 +19,7 @@ jobs:
 
       - name: Install dependencies
         run: |
-             pip install -r requirements.txt
-             pip install pytest
+          python -m pip install -e .[dev]
      
       - name: Run tests
         run: python -m pytest -vs

pyvolcans/pyvolcans.py

@@ -83,10 +83,6 @@ def cli():
         volcano_input = int(args.volcano)
     except ValueError:
         volcano_input = args.volcano
-    except PyvolcansError as exc:
-        # print error message and quit program on error
-        logging.error(exc.args[0])
-        sys.exit(1)
 
     if args.verbose:
         logging.getLogger().setLevel(logging.DEBUG)

pyvolcans/pyvolcans_func.py

@@ -591,10 +591,13 @@ def output_many_volcanoes_data(top_analogues_list, filename):
         the ID profiles (volcano data) for all the top analogue volcanoes.
     """
 
+    tmp_result_list = []
+
     with open(filename, "w") as outfile:
         for volcano in top_analogues_list:
             result_dict = get_volcano_source_data(volcano)
-            json.dump(result_dict, outfile, indent=2, sort_keys=False)
+            tmp_result_list.append(result_dict)
+        json.dump(tmp_result_list, outfile, indent=2, sort_keys=False)
 
 
 def get_analogies(my_volcano, volcans_result, count=10):

requirements.txt

@@ -9,6 +9,6 @@ thefuzz
 flake8
 ipdb
 ipython
-pylint
 pytest
+pytest-cov
 versioneer

test/test_pyvolcans.py

@@ -1,229 +1,90 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Fri May 15 12:49:55 2020
-
-@author: Vyron Christodoulou, John A. Stevenson, Pablo Tierz
-         (British Geological Survey, The Lyell Centre,
-         Edinburgh, UK).
-"""
+import os
+import subprocess
 import pytest
-
-import numpy as np
+import json
 import pandas as pd
-from pandas.testing import assert_frame_equal
-from pyvolcans.pyvolcans_func import (
-    fuzzy_matching,
-    match_name,
-    format_volcano_name,
-    get_volcano_idx_from_name,
-    get_volcano_name_from_idx,
-    get_volcano_number_from_name,
-    get_volcano_idx_from_number,
-    get_many_analogy_percentiles,
-    calculate_weighted_analogy_matrix,
-    open_gvp_website,
-    plot_bar_apriori_analogues,
-    plot_bar_better_analogues,
-    set_weights_from_args,
-    VOLCANO_NAMES,
-    PyvolcansError
-)
-
-# pylint: disable=missing-docstring
-
-
-def test_volcano_idx():
-    idx = get_volcano_idx_from_name(volcano_name='Fuego')
-    assert idx == 1071
-
-
-def test_volcano_name():
-    name = get_volcano_name_from_idx(volcano_idx=1071)
-    assert name == 'Fuego'
-
-
-def test_fuzzy_matching():
-    volc_matches = fuzzy_matching('West Eifel')
-    assert 'West Eifel Volcanic Field' in volc_matches
-
-    # Test with limit
-    volc_matches_limit = fuzzy_matching('West Eiffel', limit=3)
-    assert 'West Eifel Volcanic Field' in volc_matches_limit
-
-
-def test_volcano_number():
-    number = get_volcano_number_from_name('Santorini')
-    assert number == 212040
-
-
-def test_format_volcano_name():
-    name = format_volcano_name('Tolima, Nevado del')
-    assert name == 'Tolima_Nevado_del'
-
-
-def test_set_weights_from_args_error():
-    args_dict = {'tectonic_setting': 99.00001,
-                 'geochemistry': 99.00001,
-                 'morphology': 99.00001,
-                 'eruption_size': 99.00001,
-                 'eruption_style': 99.00001}
-
-    with pytest.raises(PyvolcansError) as exc_info:
-        set_weights_from_args(args_dict)
-
-    msg = ("Sum of weights (495.000050000) is different from 1!"
-           " Please revise your weighting scheme.")
-
-    assert str(exc_info.value) == msg
-
-
-@pytest.mark.parametrize("args_dict, expected_weights", [
-    ({'tectonic_setting': 0.2,
-      'morphology': 0.2,
-      'eruption_size': 0.2,
-      'geochemistry': 0.2,
-      'eruption_style': 0.2}, [0.2, 0.2, 0.2, 0.2, 0.2]),
-    ({'tectonic_setting': None,
-      'morphology': None,
-      'eruption_size': None,
-      'geochemistry': None,
-      'eruption_style': None}, [0.2, 0.2, 0.2, 0.2, 0.2]),
-    ({'tectonic_setting': 1,
-      'morphology': None,
-      'eruption_size': None,
-      'geochemistry': None,
-      'eruption_style': None}, [1, 0, 0, 0, 0]),
-    ({'tectonic_setting': 0.2,
-      'morphology': 0.4,
-      'eruption_size': None,
-      'geochemistry': 0.2,
-      'eruption_style': 0.2}, [0.2, 0.4, 0, 0.2, 0.2])
+from pathlib import Path
+
+
+@pytest.mark.parametrize("input_args,expected",
+        [("--help", "usage: pyvolcans"),
+         ("-h", "usage: pyvolcans"),
+         # Odd behaviour with --verbose, half of the output is written to stderr and half to stdout
+         ("Hekla --verbose", "ID profile for Hekla, Iceland (372070):"),
+         ("Hekla -v", "ID profile for Hekla, Iceland (372070):"),
+         ("Hekla --apriori Santorini", "According to PyVOLCANS"),
+         # Confirm warning raised for too many perfect analogues
+         ("Hekla -Ts 1", "UserWarning (PyVOLCANS): All top analogue volcanoes have the same value of total analogy"),
+         # Confirm command line weightings are passed through correctly
+         ("Vesuvius -Ts 1 -v", "'tectonic_setting': 1.0"),
+         ("Vesuvius -G 1 -v", "'geochemistry': 1.0"),
+         ("Vesuvius -M 1 -v", "'morphology': 1.0"),
+         ("Vesuvius -Sz 1 -v", "'eruption_size': 1.0"),
+         ("Vesuvius -St 1 -v", "'eruption_style': 1.0"),
+         ("Fuego --count 50", "Top 50")])
+def test_pyvolcans_output(input_args, expected, capfd):
+    subprocess.run(['pyvolcans', *input_args.split()])
+    out, err = capfd.readouterr()
+    assert (expected in out or expected in err)
+
+
+@pytest.mark.skipif(os.getenv('GITHUB_ACTIONS', 'false') == 'true',
+                    reason="Version number calculation doesn't work in GitHub Actions")
+@pytest.mark.parametrize("input_args,expected", [
+    ("--version", "v"),
+    ("-V", "v")
     ])
-def test_set_weights_from_args(args_dict, expected_weights):
-    names = list(args_dict.keys())
-    result = set_weights_from_args(args_dict)
-
-    assert list(result.keys()) == names
-    assert list(result.values()) == expected_weights
-
-
-def test_volcano_idx_from_number():
-    idx = get_volcano_idx_from_number(212040)
-    assert idx == 21
-
-
-@pytest.mark.parametrize("name,expected", [('blah', 'not found'), ('Santa Isabel', 'not unique')])
-def test_match_name(name, expected):
-    with pytest.raises(PyvolcansError) as excinfo:
-        match_name(name)
-    assert expected in str(excinfo.value)
-
-
-@pytest.fixture
-def mock_analogies():
-    """
-    Create mocked analogy matrices for each volcanological criterion.
-    Note: The matrix is only one item long so tests must use 'West Eifel
-    Volcanic Field' because it is first on the list.
-    """
-    mock_analogies = {'tectonic_setting': np.array([40000]),
-                      'geochemistry': np.array([4000]),
-                      'morphology': np.array([400]),
-                      'eruption_size': np.array([40]),
-                      'eruption_style': np.array([4])}
-    return mock_analogies
-
-@pytest.fixture
-def mock_weights():
-    mock_weights = {'tectonic_setting': 0.2,
-                    'geochemistry': 0.2,
-                    'morphology': 0.2,
-                    'eruption_size': 0.2,
-                    'eruption_style': 0.2}
-    return mock_weights
-
-
-def test_plot_bar_apriori_analogues(mock_weights, mock_analogies):
-    pandas_df = calculate_weighted_analogy_matrix('West Eifel Volcanic Field',
-                                                  mock_weights,
-                                                  mock_analogies)
-    df_bar = plot_bar_apriori_analogues('West Eifel Volcanic Field',
-                                        210010,
-                                        ['Hekla'],
-                                        pandas_df,
-                                        'Test_string')
-    df_expected = pd.DataFrame({'name': ['Hekla'], 'ATs': [8000.0],
-                                'AG': [800.0], 'AM': [80.0], 'ASz':[8.0],
-                                'ASt': [0.8]}, index=[1362])
-    assert_frame_equal(df_bar, df_expected)
-
-
-def test_plot_bar_better_analogues(mock_weights, mock_analogies):
-    pandas_df = calculate_weighted_analogy_matrix('West Eifel Volcanic Field',
-                                                  mock_weights,
-                                                  mock_analogies)
-    _, better_analogues = \
-        get_many_analogy_percentiles('West Eifel Volcanic Field', ['Hekla'],
-                                     pandas_df)
-
-    df_bar = plot_bar_better_analogues('West Eifel Volcanic Field',
-                                       210010,
-                                       better_analogues,
-                                       'Test_string')
-
-    df_expected = pd.DataFrame({'apriori_analogue':['Hekla'],
-                                'percentage_better': [100]})
-    assert_frame_equal(df_bar, df_expected)
-
-
-@pytest.mark.parametrize("weights, expected", [
-    ({'tectonic_setting': 0,
-      'geochemistry': 0.25,
-      'morphology': 0.25,
-      'eruption_size': 0.25,
-      'eruption_style': 0.25}, 1111),
-    ({'tectonic_setting': 0.25,
-      'geochemistry': 0,
-      'morphology': 0.25,
-      'eruption_size': 0.25,
-      'eruption_style': 0.25}, 10111),
-    ({'tectonic_setting': 0.25,
-      'geochemistry': 0.25,
-      'morphology': 0,
-      'eruption_size': 0.25,
-      'eruption_style': 0.25}, 11011),
-    ({'tectonic_setting': 0.25,
-      'geochemistry': 0.25,
-      'morphology': 0.25,
-      'eruption_size': 0,
-      'eruption_style': 0.25}, 11101),
-    ({'tectonic_setting': 0.25,
-      'geochemistry': 0.25,
-      'morphology': 0.25,
-      'eruption_size': 0.25,
-      'eruption_style': 0}, 11110)])
-def test_combined_analogy_matrix_no_tectonic(weights, expected, mock_analogies):
-    pandas_df = calculate_weighted_analogy_matrix(
-        'West Eifel Volcanic Field', weights, mock_analogies)
-    matrix = pandas_df.loc[get_volcano_idx_from_name(
-        'West Eifel Volcanic Field'), 'total_analogy']
-    assert matrix.astype(int) == expected
-
-
-def test_open_gvp_website(monkeypatch):
-    # Arrange
-    def always_false(my_web):
-        # This function will replace webbrowser.open and always returns false
-        # We have my_web as an argument so our function has the same inputs as
-        # webbrowser.open
-        return False
-
-    monkeypatch.setattr('pyvolcans.pyvolcans_func.webbrowser.open', always_false)
-
-    # Act
-    with pytest.raises(PyvolcansError) as exc_info:
-        open_gvp_website(123456)
-
+def test_pyvolcans_version_number_reporting(input_args, expected, capfd):
+    subprocess.run(['pyvolcans', *input_args.split()])
+    out, err = capfd.readouterr()
+    assert (expected in out or expected in err)
+
+
+@pytest.mark.parametrize("input_args,expected",
+                         [("Hekla -ovd", "Hekla"),
+                          ("Hekla -oad", "Torfajokull"),
+                          ("Fuego -ovd", "Fuego"),
+                          ("Fuego -oad", "Klyuchevskoy"),
+                          ("Sabancaya -oad", "Peuet Sague")])
+def test_write_json_files(input_args, expected, tmp_path):
+    subprocess.run(['pyvolcans', '--verbose', *input_args.split()],
+                    cwd=tmp_path)
+    fname = list(Path(tmp_path).glob("*.json"))[0]
+    with open(fname) as f:
+        data = json.load(f)
+    #`-ovd` returns a dict, `-oad` returns a list of dict
+    if type(data) == dict:
+        assert data['name'] == expected
+    elif type(data) == list:
+        top1_analogue = data[0]
+        assert top1_analogue['name'] == expected
+
+
+@pytest.mark.parametrize("input_args,expected",
+                         [("Alutu -w", "222040"),
+                          ("Vulcano -w", "263310")])
+def test_write_csv_files(input_args, expected, tmp_path):
+    # Arrange / Action
+    subprocess.run(['pyvolcans', '--verbose', *input_args.split()],
+                    cwd=tmp_path)
+    fname = list(Path(tmp_path).glob("*.csv"))[0]
+    data = pd.read_csv(fname)
+    top1_analogue = data.iloc[0, ]
     # Assert
-    msg = "No suitable browser to open https://volcano.si.edu/volcano.cfm?vn=123456&vtab=GeneralInfo"
-    assert str(exc_info.value) == msg
+    assert top1_analogue['smithsonian_id'] == int(expected)
+
+@pytest.mark.parametrize("input_args,expected",
+                         [("Fuego -G 99", "PyVOLCANS: Sum of weights"),
+                          ("Fuego -Sz -1", "PyVOLCANS: Some criterion weights"),
+                          ("Fuigu", "Fuigu not found!"),
+                          ("342090111", "Volcano number does not exist"),
+                          ("-iurwhfgl", "arguments are required: volcano"),
+                          ("Fuego --apriori Tungurahua Villarrico",
+                           "Villarrico not found!"),
+                          ("Fuego --apriori 352010 -897",
+                           "Volcano number does not exist")])
+def test_pyvolcans_errors(input_args, expected, capfd):
+    subprocess.run(['pyvolcans', *input_args.split()])
+    _, err = capfd.readouterr()
+
+    assert expected in err