def test_scenario1(self):
"""
Scenario: Successfully creating a batch prediction:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
When I create a batch prediction for the dataset with the model
And I wait until the batch prediction is ready less than <time_4> secs
And I download the created predictions file to "<local_file>"
Then the batch prediction file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | time_3 | time_4 | local_file | predictions_file |
| ../data/iris.csv | 30 | 30 | 50 | 50 | ./tmp/batch_predictions.csv |./data/batch_predictions.csv |
"""
print self.test_scenario1.__doc__
examples = [
['data/iris.csv', '30', '30', '50', '50', 'tmp/batch_predictions.csv', 'data/batch_predictions.csv']]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
batch_pred_create.i_create_a_batch_prediction(self)
batch_pred_create.the_batch_prediction_is_finished_in_less_than(self, example[4])
batch_pred_create.i_download_predictions_file(self, example[5])
batch_pred_create.i_check_predictions(self, example[6])
def test_scenario2(self):
"""
Scenario: Successfully creating a batch prediction for an ensemble:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an ensemble of <number_of_models> models and <tlp> tlp
And I wait until the ensemble is ready less than <time_3> secs
When I create a batch prediction for the dataset with the ensemble
And I wait until the batch prediction is ready less than <time_4> secs
And I download the created predictions file to "<local_file>"
Then the batch prediction file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | number_of_models | tlp | time_3 | time_4 | local_file | predictions_file |
| ../data/iris.csv | 30 | 30 | 5 | 1 | 80 | 50 | ./tmp/batch_predictions.csv | ./data/batch_predictions_e.csv |
"""
print self.test_scenario2.__doc__
examples = [
['data/iris.csv', '30', '30', '5', '1', '80', '50', 'tmp/batch_predictions.csv', 'data/batch_predictions_e.csv']]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
ensemble_create.i_create_an_ensemble(self, example[3], example[4])
ensemble_create.the_ensemble_is_finished_in_less_than(self, example[5])
batch_pred_create.i_create_a_batch_prediction_ensemble(self)
batch_pred_create.the_batch_prediction_is_finished_in_less_than(self, example[6])
batch_pred_create.i_download_predictions_file(self, example[7])
batch_pred_create.i_check_predictions(self, example[8])
def test_scenario2(self):
"""
Scenario: Successfully creating a batch prediction for an ensemble:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an ensemble of <number_of_models> models and <tlp> tlp
And I wait until the ensemble is ready less than <time_3> secs
When I create a batch prediction for the dataset with the ensemble
And I wait until the batch prediction is ready less than <time_4> secs
And I download the created predictions file to "<local_file>"
Then the batch prediction file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | number_of_models | tlp | time_3 | time_4 | local_file | predictions_file |
| ../data/iris.csv | 30 | 30 | 5 | 1 | 80 | 50 | ./tmp/batch_predictions.csv | ./data/batch_predictions_e.csv |
"""
print self.test_scenario2.__doc__
examples = [
['data/iris.csv', '30', '30', '5', '1', '80', '50', 'tmp/batch_predictions.csv', 'data/batch_predictions_e.csv']]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
ensemble_create.i_create_an_ensemble(self, example[3], example[4])
ensemble_create.the_ensemble_is_finished_in_less_than(self, example[5])
batch_pred_create.i_create_a_batch_prediction_ensemble(self)
batch_pred_create.the_batch_prediction_is_finished_in_less_than(self, example[6])
batch_pred_create.i_download_predictions_file(self, example[7])
batch_pred_create.i_check_predictions(self, example[8])
def test_scenario5(self):
"""
Scenario: Successfully creating a batch anomaly score from an anomaly detector:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an anomaly detector
And I wait until the anomaly detector is ready less than <time_3> secs
When I create a batch anomaly score
And I check the batch anomaly score is ok
And I wait until the batch anomaly score is ready less than <time_4> secs
And I download the created anomaly score file to "<local_file>"
Then the batch anomaly score file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | time_3 | time_4 | local_file | predictions_file |
| ../data/tiny_kdd.csv | 30 | 30 | 50 | 50 | ./tmp/batch_predictions.csv |./data/batch_predictions_a.csv |
"""
print self.test_scenario5.__doc__
examples = [
['data/tiny_kdd.csv', '30', '30', '50', '50', 'tmp/batch_predictions.csv', 'data/batch_predictions_a.csv']]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
anomaly_create.i_create_an_anomaly(self)
anomaly_create.the_anomaly_is_finished_in_less_than(self, example[3])
batch_pred_create.i_create_a_batch_prediction_with_anomaly(self)
batch_pred_create.the_batch_anomaly_score_is_finished_in_less_than(self, example[4])
batch_pred_create.i_download_anomaly_score_file(self, example[5])
batch_pred_create.i_check_predictions(self, example[6])
def test_scenario1(self):
"""
Scenario: Successfully creating a batch prediction:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model
And I wait until the model is ready less than <time_3> secs
When I create a batch prediction for the dataset with the model
And I wait until the batch prediction is ready less than <time_4> secs
And I download the created predictions file to "<local_file>"
Then the batch prediction file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | time_3 | time_4 | local_file | predictions_file |
| ../data/iris.csv | 30 | 30 | 50 | 50 | ./tmp/batch_predictions.csv |./data/batch_predictions.csv |
"""
print self.test_scenario1.__doc__
examples = [
['data/iris.csv', '30', '30', '50', '50', 'tmp/batch_predictions.csv', 'data/batch_predictions.csv']]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_model(self)
model_create.the_model_is_finished_in_less_than(self, example[3])
batch_pred_create.i_create_a_batch_prediction(self)
batch_pred_create.the_batch_prediction_is_finished_in_less_than(self, example[4])
batch_pred_create.i_download_predictions_file(self, example[5])
batch_pred_create.i_check_predictions(self, example[6])
def test_scenario5(self):
"""
Scenario: Successfully creating a batch anomaly score from an anomaly detector:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create an anomaly detector
And I wait until the anomaly detector is ready less than <time_3> secs
When I create a batch anomaly score
And I check the batch anomaly score is ok
And I wait until the batch anomaly score is ready less than <time_4> secs
And I download the created anomaly score file to "<local_file>"
Then the batch anomaly score file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | time_3 | time_4 | local_file | predictions_file |
| ../data/tiny_kdd.csv | 30 | 30 | 50 | 50 | ./tmp/batch_predictions.csv |./data/batch_predictions_a.csv |
"""
print self.test_scenario5.__doc__
examples = [
['data/tiny_kdd.csv', '30', '30', '50', '50', 'tmp/batch_predictions.csv', 'data/batch_predictions_a.csv']]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
anomaly_create.i_create_an_anomaly(self)
anomaly_create.the_anomaly_is_finished_in_less_than(self, example[3])
batch_pred_create.i_create_a_batch_prediction_with_anomaly(self)
batch_pred_create.the_batch_anomaly_score_is_finished_in_less_than(self, example[4])
batch_pred_create.i_download_anomaly_score_file(self, example[5])
batch_pred_create.i_check_predictions(self, example[6])
def test_scenario3(self):
"""
Scenario 3: Successfully creating a fusion from a dataset:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I retrieve a list of remote models tagged with "<tag>"
And I create a fusion from a list of models
And I wait until the fusion is ready less than <time_4> secs
When I create a batch prediction for the dataset with the fusion
And I wait until the batch prediction is ready less than <time_4> secs
And I download the created predictions file to "<local_file>"
Then the batch prediction file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | time_3 | time_4 | tag | local_file | predictions_file |
| ../data/iris.csv | 10 | 10 | 20 | 20 | mytag | ./tmp/batch_predictions.csv | ./data/batch_predictions_fs.csv |
"""
print self.test_scenario3.__doc__
examples = [[
'data/iris.csv', '10', '10', '20', '20',
'{"tags":["my_fusion_3_tag"]}', 'my_fusion_3_tag',
'tmp/batch_predictions.csv', 'data/batch_predictions_fs.csv'
]]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
compare_pred.i_retrieve_a_list_of_remote_models(self, example[6])
model_create.i_create_a_fusion(self)
model_create.the_fusion_is_finished_in_less_than(self, example[3])
batch_pred_create.i_create_a_batch_prediction_fusion(self)
batch_pred_create.the_batch_prediction_is_finished_in_less_than(
self, example[4])
batch_pred_create.i_download_predictions_file(self, example[7])
batch_pred_create.i_check_predictions(self, example[8])
def test_scenario3(self):
"""
Scenario 3: Successfully creating a fusion:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I create a model with "<params>"
And I wait until the model is ready less than <time_3> secs
And I retrieve a list of remote models tagged with "<tag>"
And I create a fusion from a list of models
And I wait until the fusion is ready less than <time_4> secs
When I create a batch prediction for the dataset with the fusion
And I wait until the batch prediction is ready less than <time_4> secs
And I download the created predictions file to "<local_file>"
Then the batch prediction file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | time_3 | time_4 | tag | local_file | predictions_file |
| ../data/iris.csv | 10 | 10 | 20 | 20 | mytag | ./tmp/batch_predictions.csv | ./data/batch_predictions_fs.csv |
"""
print self.test_scenario3.__doc__
examples = [
['data/iris.csv', '10', '10', '20', '20',
'{"tags":["my_fusion_3_tag"]}', 'my_fusion_3_tag',
'tmp/batch_predictions.csv', 'data/batch_predictions_fs.csv']]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
model_create.i_create_a_model_with(self, example[5])
model_create.the_model_is_finished_in_less_than(self, example[3])
compare_pred.i_retrieve_a_list_of_remote_models(self, example[6])
model_create.i_create_a_fusion(self)
model_create.the_fusion_is_finished_in_less_than(self, example[3])
batch_pred_create.i_create_a_batch_prediction_fusion(self)
batch_pred_create.the_batch_prediction_is_finished_in_less_than(self, example[4])
batch_pred_create.i_download_predictions_file(self, example[7])
batch_pred_create.i_check_predictions(self, example[8])
def test_scenario3(self):
"""
Scenario: Successfully creating a batch centroid from a cluster:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a cluster
And I wait until the cluster is ready less than <time_3> secs
When I create a batch centroid for the dataset
And I check the batch centroid is ok
And I wait until the batch centroid is ready less than <time_4> secs
And I download the created centroid file to "<local_file>"
Then the batch centroid file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | time_3 | time_4 | local_file | predictions_file |
| ../data/diabetes.csv | 50 | 50 | 50 | 50 | ./tmp/batch_predictions.csv |./data/batch_predictions_c.csv |
"""
print self.test_scenario3.__doc__
examples = [[
'data/diabetes.csv', '50', '50', '50', '50',
'tmp/batch_predictions.csv', 'data/batch_predictions_c.csv'
]]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example[2])
cluster_create.i_create_a_cluster(self)
cluster_create.the_cluster_is_finished_in_less_than(
self, example[3])
batch_pred_create.i_create_a_batch_prediction_with_cluster(self)
batch_pred_create.the_batch_centroid_is_finished_in_less_than(
self, example[4])
batch_pred_create.i_download_centroid_file(self, example[5])
batch_pred_create.i_check_predictions(self, example[6])
def test_scenario3(self):
"""
Scenario: Successfully creating a batch centroid from a cluster:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <time_1> secs
And I create a dataset
And I wait until the dataset is ready less than <time_2> secs
And I create a cluster
And I wait until the cluster is ready less than <time_3> secs
When I create a batch centroid for the dataset
And I check the batch centroid is ok
And I wait until the batch centroid is ready less than <time_4> secs
And I download the created centroid file to "<local_file>"
Then the batch centroid file is like "<predictions_file>"
Examples:
| data | time_1 | time_2 | time_3 | time_4 | local_file | predictions_file |
| ../data/diabetes.csv | 50 | 50 | 50 | 50 | ./tmp/batch_predictions.csv |./data/batch_predictions_c.csv |
"""
print self.test_scenario3.__doc__
examples = [
["data/diabetes.csv", "50", "50", "50", "50", "tmp/batch_predictions.csv", "data/batch_predictions_c.csv"]
]
for example in examples:
print "\nTesting with:\n", example
source_create.i_upload_a_file(self, example[0])
source_create.the_source_is_finished(self, example[1])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(self, example[2])
cluster_create.i_create_a_cluster(self)
cluster_create.the_cluster_is_finished_in_less_than(self, example[3])
batch_pred_create.i_create_a_batch_prediction_with_cluster(self)
batch_pred_create.the_batch_centroid_is_finished_in_less_than(self, example[4])
batch_pred_create.i_download_centroid_file(self, example[5])
batch_pred_create.i_check_predictions(self, example[6])
