def test_client_cli_predict_non_zero_exit(
should_fail,
start_date,
end_date,
caplog,
gordo_project,
influxdb,
influxdb_uri,
influxdb_measurement,
ml_server,
):
"""
Test ability for client to get predictions via CLI
"""
runner = CliRunner()
# Should fail requesting dates which clearly don't exist.
args = [
"client",
"--metadata",
"key,value",
"--project",
gordo_project,
"predict",
start_date,
end_date,
]
data_provider = providers.InfluxDataProvider(
measurement=influxdb_measurement, value_name="Value", uri=influxdb_uri)
args.extend(["--data-provider", json.dumps(data_provider.to_dict())])
# Run without any error
with caplog.at_level(logging.CRITICAL):
with patch(
"gordo.machine.dataset.sensor_tag._asset_from_tag_name",
side_effect=lambda *args, **kwargs: "default",
):
out = runner.invoke(cli.gordo, args=args)
if should_fail:
assert out.exit_code != 0, f"{out.output or out.exception}"
else:
assert out.exit_code == 0, f"{out.output or out.exception}"
def test_client_predictions_diff_batch_sizes(
gordo_project,
gordo_single_target,
influxdb,
influxdb_uri,
influxdb_measurement,
ml_server,
batch_size: int,
use_parquet: bool,
):
"""
Run the prediction client with different batch-sizes and whether to use
a data provider or not.
"""
# Time range used in this test
start, end = (
isoparse("2016-01-01T00:00:00+00:00"),
isoparse("2016-01-01T12:00:00+00:00"),
)
# Client only used within the this test
test_client = client_utils.influx_client_from_uri(influxdb_uri)
# Created measurements by prediction client with dest influx
query = f"""
SELECT *
FROM "model-output"
WHERE("machine" =~ /^{gordo_single_target}$/)
"""
# Before predicting, influx destination db should be empty for 'predictions' measurement
vals = test_client.query(query)
assert len(vals) == 0
data_provider = providers.InfluxDataProvider(
measurement=influxdb_measurement,
value_name="Value",
client=client_utils.influx_client_from_uri(uri=influxdb_uri,
dataframe_client=True),
)
prediction_client = Client(
project=gordo_project,
data_provider=data_provider,
prediction_forwarder=ForwardPredictionsIntoInflux( # type: ignore
destination_influx_uri=influxdb_uri),
batch_size=batch_size,
use_parquet=use_parquet,
parallelism=10,
)
assert len(prediction_client.get_machine_names()) == 1
# Get predictions
predictions = prediction_client.predict(start=start, end=end)
assert isinstance(predictions, list)
assert len(predictions) == 1
name, predictions, error_messages = predictions[
0] # First dict of predictions
assert isinstance(name, str)
assert isinstance(predictions, pd.DataFrame)
assert isinstance(error_messages, list)
assert isinstance(predictions.index,
pd.core.indexes.datetimes.DatetimeIndex)
# This should have resulted in writting predictions to influx
# Before predicting, influx destination db should be empty
vals = test_client.query(query)
assert (
len(vals) > 0
), f"Expected new values in 'predictions' measurement, but found {vals}"
self.assertEqual(series_collection[0].name, "ab.*")
self.assertEqual(series_collection[1].name, ".*b.*")
@pytest.mark.parametrize(
"provider,expected_params",
(
(
providers.RandomDataProvider(200, max_size=205),
{
"min_size": 200,
"max_size": 205
},
),
(
providers.InfluxDataProvider("measurement", value_name="Value"),
{
"measurement": "measurement",
"value_name": "Value"
},
),
),
)
def test_data_provider_serializations(provider: GordoBaseDataProvider,
expected_params: dict):
"""
Test a given provider can be serialized to dict and back
"""
encoded = provider.to_dict()