def test_add_data_single_thing(self): fclient = FClient(host=host, token=token) eventbuffer = Schemas.Eventbuffer() eventbuffer.set_name('Motor Health') eventbuffer.set_time_identifier('time') eventbuffer.set_time_format('iso_8601') try: eventbuffer = fclient.create_eventbuffer(eventbuffer) try: data = '{"time" :"2016-03-01 01:01:01", "current" : 12.4, "vibration" : 3.4, "state" : "On"}' response = fclient.add_input_data(eventbuffer.get_id(), 'json', {}, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to eventbuffer') # tear down try: fclient.delete_pipeline(created_pipeline.get_id()) fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot add input data to eventbuffer') except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot create eventbuffer')
def test_create_pipeline_with_multiple_assessment(self): fclient = FClient(host=host, token=token) eventbuffer = Schemas.Eventbuffer() eventbuffer.set_name('Motor Health' + str(random.random())) eventbuffer.set_time_identifier('time') eventbuffer.set_time_format('iso_8601') eventbuffer.set_thing_identifier('motor') try: eventbuffer = fclient.create_eventbuffer(eventbuffer) data = "time, motor, current, vibration, state\n" + "2016-03-01 01:01:01, Motor1, 12.4, 3.4, On" try: response = fclient.add_input_data(eventbuffer.get_id(), 'csv', {}, data) pipeline = Schemas.Pipeline() signals = { 'current': ['Numeric','Occurrences'], 'vibration': ['Numeric','Samples'], 'state': 'Categorical' } assessment = Schemas.Assessment() assessment.set_name('Health') \ .set_input_signals(['current', 'vibration', 'state']) assessment2 = Schemas.Assessment() assessment2.set_name('Health2') \ .set_input_signals(['vibration', 'state']) pipeline.set_name('Motor Health 1') \ .set_eventbuffer(eventbuffer.get_id()) \ .set_input_signals(signals) \ .set_assessment(assessment) \ .set_assessment(assessment2) try: response = fclient.create_pipeline(pipeline) self.assertEqual(isinstance(response, Schemas.Pipeline), True, 'Invalid Pipeline object after creation') self.assertEqual(isinstance(response.get_id(), unicode), True, 'Invalid Pipeline object after creation') self.assertEqual(response.get_name(), pipeline.get_name(), 'Invalid Pipeline object after creation') self.assertEqual(response.get_thing_identifier(), eventbuffer.get_thing_identifier(), 'Invalid Pipeline object after creation') self.assertEqual(len(response.get_input_signals()), 3, 'Invalid Pipeline object after creation') self.assertEqual(len(response.get_assessments()), 2, 'Invalid Pipeline object after creation') self.assertEqual(response.get_eventbuffer(), eventbuffer.get_id(), 'Invalid Pipeline object after creation') # tear down try: fclient.delete_pipeline(response.get_id()) fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass except Exception as e: print(e.message) try: fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass self.assertEqual(0, 1, 'Cannot create pipeline') except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot add data') except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot create eventbuffer')
def test_create_pipeline_for_single_thing(self): fclient = FClient(host=host, token=token) eventbuffer = Schemas.Eventbuffer() eventbuffer.set_name('Motor Health' + str(random.random())) eventbuffer.set_time_identifier('time') eventbuffer.set_time_format('iso_8601') try: eventbuffer = fclient.create_eventbuffer(eventbuffer) data = '{"time" :"2016-03-01 01:01:01", "current" : 12.4, "vibration" : 3.4, "state" : "On"}' try: response = fclient.add_input_data(eventbuffer.get_id(), 'json', {}, data) pipeline = Schemas.Pipeline() signals = { 'current': 'Numeric', 'vibration': 'Numeric', 'state': 'Categorical' } assessment = Schemas.Assessment() assessment.set_name('Health') \ .set_input_signals(['current', 'vibration', 'state']) pipeline.set_name('Motor Health 1') \ .set_eventbuffer(eventbuffer.get_id()) \ .set_input_signals(signals) \ .set_assessment(assessment) try: response = fclient.create_pipeline(pipeline) self.assertEqual(isinstance(response, Schemas.Pipeline), True, 'Invalid Pipeline object after creation') self.assertEqual(isinstance(response.get_id(), unicode), True, 'Invalid Pipeline object after creation') self.assertEqual(response.get_name(), pipeline.get_name(), 'Invalid Pipeline object after creation') self.assertNotEqual(response.get_thing_name(), None, 'Invalid Pipeline object after creation') self.assertEqual(len(response.get_input_signals()), 3, 'Invalid Pipeline object after creation') self.assertEqual(len(response.get_assessments()), 1, 'Invalid Pipeline object after creation') self.assertEqual(response.get_eventbuffer(), eventbuffer.get_id(), 'Invalid Pipeline object after creation') # tear down try: fclient.delete_pipeline(response.get_id()) fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass except Exception as e: print(e.message) try: fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass self.assertEqual(0, 1, 'Cannot create pipeline') except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot add data') except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot create eventbuffer')
def test_add_json_verification(self): fclient = FClient(host=host, token=token) eventbuffer = Schemas.Eventbuffer() eventbuffer.set_name('Motor Health' + str(random.random())) eventbuffer.set_time_identifier('time') eventbuffer.set_time_format('iso_8601') try: eventbuffer = fclient.create_eventbuffer(eventbuffer) try: data = '{"time" :"2016-03-01 01:01:01", "current" : 12.4, "vibration" : 3.4, "state" : "On"}' response = fclient.add_input_data(eventbuffer.get_id(), 'json', {}, data) pipeline = Schemas.Pipeline() signals = { 'current': 'Numeric', 'vibration': 'Numeric', 'state': 'Categorical' } assessment = Schemas.Assessment() assessment.set_name('Health') \ .set_input_signals(['current', 'vibration', 'state']) pipeline.set_name('Motor Health 1') \ .set_eventbuffer(eventbuffer.get_id()) \ .set_input_signals(signals) \ .set_assessment(assessment) try: resp_pipeline = fclient.create_pipeline(pipeline) data = io.open('./verificationData.json') response = fclient.add_verification( resp_pipeline.get_id(), 'json', {}, data) # tear down try: fclient.delete_pipeline(resp_pipeline.get_id()) fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass except Exception as e: print(e.message) try: fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass self.assertEqual(0, 1, 'Cannot create pipeline') except Exception as e: print(e.message) self.assertEqual(0, 1, "Cannot add data") except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot create eventbuffer')
def test_add_json_verification(self): fclient = FClient(host=host, token=token) eventbuffer = Schemas.Eventbuffer() eventbuffer.set_name('Motor Health' + str(random.random())) eventbuffer.set_time_identifier('time') eventbuffer.set_time_format('iso_8601') try: eventbuffer = fclient.create_eventbuffer(eventbuffer) try: data = '{"time" :"2016-03-01 01:01:01", "current" : 12.4, "vibration" : 3.4, "state" : "On"}' response = fclient.add_input_data(eventbuffer.get_id(), 'json', {}, data) pipeline = Schemas.Pipeline() signals = { 'current': 'Numeric', 'vibration': 'Numeric', 'state': 'Categorical' } assessment = Schemas.Assessment() assessment.set_name('Health') \ .set_input_signals(['current', 'vibration', 'state']) pipeline.set_name('Motor Health 1') \ .set_eventbuffer(eventbuffer.get_id()) \ .set_input_signals(signals) \ .set_assessment(assessment) try: resp_pipeline = fclient.create_pipeline(pipeline) data = '{"time" : "2011-03-26T12:00:00Z", "car" : "HI3821", "end" : "2012-06-01T00:00:00Z", "Health" : "Normal"}' response = fclient.add_verification(resp_pipeline.get_id(), 'json', {}, data) # tear down try: fclient.delete_pipeline(resp_pipeline.get_id()) fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass except Exception as e: print(e.message) try: fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass self.assertEqual(0, 1, 'Cannot create pipeline') except Exception as e: print(e.message) self.assertEqual(0,1,"Cannot add data") except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot create eventbuffer')
class TestAddFacts(unittest.TestCase): def setUp(self): self.fclient = FClient(host=host, token=token, options=None) self.created_datastreams = [] pass # Add facts data (json format) to Assessment def test_add_json_facts(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier("car") datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment(asmtRequest) # adding fact data = '{"time" : "2011-03-26T12:00:00.000Z", "car" : "HI3821", "end" : "2012-06-01T00:00:00.000Z", "Health" : "Normal"}' options = { 'startTimeIdentifier': "time", 'endTimeIdentifier': "end", 'timeFormat': "iso_8601", 'timeZone': time.get_zone(), 'entityIdentifier': "car", 'valueIdentifier': "Health" } response = self.fclient.add_facts(resp_assessment.get_id(), 'json', options, data) # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, "Cannot create datastream") # Add facts data (csv format) to Assessment def test_add_csv_facts(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment(asmtRequest) # adding fact to the assessment data = "time,end,car,Health\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,IL9753,Normal\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,HI3821,Normal" options = { 'startTimeIdentifier': "time", 'endTimeIdentifier': "end", 'timeFormat': "iso_8601", 'timeZone': time.get_zone(), 'valueIdentifier': "Health" } response = self.fclient.add_facts(resp_assessment.get_id(), 'csv', options, data) # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, "Cannot create datastream") # Add facts data (csv format) with tags to Assessment def test_add_csv_facts_with_tags(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment(asmtRequest) data = "time,end,car,Health,Tags\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,IL9753,Normal,testTag1\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,HI3821,Normal,testTag2" options = { 'startTimeIdentifier': "time", 'endTimeIdentifier': "end", 'timeFormat': "iso_8601", 'timeZone': time.get_zone(), 'valueIdentifier': "Health", 'tagIdentifier': 'Tags' } # adding fact response = self.fclient.add_facts(resp_assessment.get_id(), 'csv', options, data) # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, "Cannot create datastream") # Add facts data (csv format) with additional Tag to Assessment def test_add_csv_facts_with_additional_tags(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment(asmtRequest) data = "time,end,car,Health\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,IL9753,Normal\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,HI3821,Normal" options = { 'startTimeIdentifier': "time", 'endTimeIdentifier': "end", 'timeFormat': "iso_8601", 'timeZone': time.get_zone(), 'valueIdentifier': "Health", 'additionalTag': 'testTag' } response = self.fclient.add_facts(resp_assessment.get_id(), 'csv', options, data) # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, "Cannot create datastream") # Add facts data (csv format) with batch identifier to Assessment def test_add_csv_fact_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_batchIdentifier('batches') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment( asmtRequest) data = '{"time" : 123898422222, "batches" : "batch_1", "signal" : "current", "value" : 12.4}\n' \ '{"time" : 123898422322, "batches" : "batch_2", "signal" : "current", "value" : 12.4}' options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'signalIdentifier': 'signal', 'valueIdentifier': 'value', 'batchIdentifier': 'batches' } # adding data to the created datastream response = self.fclient.add_input_data( datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) # adding fact to the assessment data = "batchId,value\n" \ "batch_1,normal\n" \ "batch_2,abnormal" options = { 'valueIdentifier': "value", 'batchIdentifier': 'batchId' } response = self.fclient.add_facts(resp_assessment.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add fact data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) try: self.fclient.delete_datastream( datastreamResponse.get_id()) except Exception as e: pass self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual( 0, 1, 'Cannot add input or fact data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') def tearDown(self): # teardown for ds in self.created_datastreams: try: self.fclient.delete_datastream(ds) except Exception as e: print(exception_handler(e)) pass
class TestAddDataStream(unittest.TestCase): def setUp(self): self.fclient = FClient(host=host, token=token, options=None) self.created_datastreams = [] pass # Add historical wide input data (json format) to single entity Datastream (Used for model revision) def test_add_historical_json_data_stream(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = io.open('./resources/data.json') options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier() } # adding data to the datastream response = self.fclient.add_input_stream( datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add historical input data (csv format) from a stream to single entity Datastream (Used for model revision) def test_add_historical_csv_data_stream(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = io.open('./resources/data.csv') options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier() } # adding data to datstream response = self.fclient.add_input_stream( datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add historical input data (csv format) from a stream to Multi entity Datastream (Used for model revision) def test_add_historical_csv_data_stream_multi(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = io.open('./resources/dataMultiEntity.csv') options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'entityIdentifier': 'car', 'valueIdentifier': 'value', 'signalIdentifier': 'signal' } response = self.fclient.add_input_stream( datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add live input data (csv format) from a stream to Datastream (Used for live monitoring) @unittest.skip("streaming can only be done once ") # Streaming data can only be sent to datastream if datastream is live. So make sure that datastream is live first def test_add_streaming_csv_data_stream(self): datastreamId = 'datstream-id' # id of the datastream which is live try: data = io.open('./resources/data.csv') options = {'streaming': True, 'hasMoreData': False} response = self.fclient.add_input_data(datastreamId, 'csv', options, data) self.assertNotEqual( response, 'Data Submitted Successfully', 'Cannot add historical input data to datastream') except Exception as e: # if response is "{"message":"Datastream is not live, streaming data cannot be accepted."}" Please turn on datastream first then add streaming data print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') # Add live input data (json format) from a stream to Datastream (Used for live monitoring) @unittest.skip("streaming can only be done once ") # Streaming data can only be sent to datastream if datastream is live. So make sure that datastream is live first def test_add_streaming_json_data_stream(self): datastreamId = 'datstream-id' # id of the datastream which is live try: data = io.open('./resources/data.json') options = {'streaming': True, 'hasMoreData': False} response = self.fclient.add_input_data(datastreamId, 'json', options, data) self.assertNotEqual( response, 'Data Submitted Successfully', 'Cannot add historical input data to datastream') except Exception as e: # if response is "{"message":"Datastream is not live, streaming data cannot be accepted."}" Please turn on datastream first then add streaming data print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') def tearDown(self): # teardown for ds in self.created_datastreams: try: self.fclient.delete_datastream(ds) except Exception as e: print(exception_handler(e)) pass
class TestAddData(unittest.TestCase): def setUp(self): self.fclient = FClient(host=host, token=token, options=None) self.created_datastreams = [] pass # Add narrow input data (json format) to multi entity Datastream def test_add_data_json_mutli(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") signal.set_signalIdentifier("signal") signal.set_valueIdentifier("value") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = '{"time" : "2016-03-01 01:01:01", "signal" : "current", "value" : 12.4, "car" : "unit1"}' options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'signalIdentifier': 'signal', 'valueIdentifier': 'value', 'entityIdentifier': 'car' } # adding data to the created datastream response = self.fclient.add_input_data( datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add narrow input data (csv format) to single entity to Datastream def test_add_data_csv_single(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() signal.set_valueIdentifier("value") signal.set_signalIdentifier("signal") time.set_zone("GMT") time.set_identifier("time") time.set_format("iso_8601") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # input data has timeformat different than the one set while creating datastream data = "time, signal, value " + "\n" + "2016-03-01 01:01:01, signal1, 3.4" + "\n" + "2016-03-01 01:01:01, signal2, 1.4" options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': "YYYY-MM-DD HH:mm:ss", 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier() } response = self.fclient.add_input_data( datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add wide input data (json format) to single entity Datastream def test_add_data_json_single(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityName('machine') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # adding data to datastream data = '{"time" :"2016-03-01 01:01:01", "current" : 12.4, "vibration" : 3.4, "state" : "On"}' options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'entityName': 'machine' } response = self.fclient.add_input_data( datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add wide input data (csv format) to multi entity Datastream def test_add_data_csv_multi(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = "time,current,vibrarion,state,car" + "\n" + "2016-03-01 01:01:01,12.4,3.4,on,car1" + "\n" + "2016-03-01 01:01:01,31.2,1.4,off,car1" + "\n" + "2016-03-01 01:01:01,24,3.2,on,car2" + "\n" + "2016-03-01 01:01:01,31,3.4,off,car2" options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'entityIdentifier': 'car' } response = self.fclient.add_input_data( datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Cannot add data due to missing time Identifer def test_add_data_csv_multi_miss_time_identifier(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = "time,current,vibrarion,state,car" + "\n" + "2016-03-01 01:01:01,12.4,3.4,on,car1" + "\n" + "2016-03-01 01:01:01,31.2,1.4,off,car1" + "\n" + "2016-03-01 01:01:01,24,3.2,on,car2" + "\n" + "2016-03-01 01:01:01,31,3.4,off,car2" options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'entityIdentifier': 'car' } response = self.fclient.add_input_data( datastreamResponse.get_id(), 'csv', options, data) self.assertEqual(0, 1, 'Missing time identifer error not caught') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: # Printing only for debugging purposes print("\nResponse :", exception_handler(e)) self.assertEqual(exception_handler(e), "Missing time identifier.", 'Missing time identifer error not caught') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Cannot add data due to missing time zone def test_add_data_csv_multi_miss_time_zone(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = "time,current,vibrarion,state,car" + "\n" + "2016-03-01 01:01:01,12.4,3.4,on,car1" + "\n" + "2016-03-01 01:01:01,31.2,1.4,off,car1" + "\n" + "2016-03-01 01:01:01,24,3.2,on,car2" + "\n" + "2016-03-01 01:01:01,31,3.4,off,car2" options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeIdentifier': time.get_identifier(), 'entityIdentifier': 'car' } response = self.fclient.add_input_data( datastreamResponse.get_id(), 'csv', options, data) self.assertEqual(0, 1, 'Missing time zone error not caught') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: # (b'{"message":"Missing time zone."}',) print("\nResponse :", exception_handler(e)) self.assertEqual(exception_handler(e), "Missing time zone.", 'Missing time zone error not caught') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Cannot add data due to missing time format def test_add_data_csv_multi_miss_time_format(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = "time,current,vibrarion,state,car" + "\n" + "2016-03-01 01:01:01,12.4,3.4,on,car1" + "\n" + "2016-03-01 01:01:01,31.2,1.4,off,car1" + "\n" + "2016-03-01 01:01:01,24,3.2,on,car2" + "\n" + "2016-03-01 01:01:01,31,3.4,off,car2" options = { 'streaming': False, 'hasMoreData': False, 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'entityIdentifier': 'car' } response = self.fclient.add_input_data( datastreamResponse.get_id(), 'csv', options, data) self.assertEqual(0, 1, 'Missing time format error not caught') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: # Printing only for debugging purposes print('\nResponse :', exception_handler(e)) self.assertEqual(exception_handler(e), "Missing time format.", 'Missing time format error not caught') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add live input data (json format) to Datastream (Used for live monitoring) @unittest.skip("Skipping streaming data ingestion") # Streaming data can only be sent to datastream if datastream is live. So make sure that datastream is live first def test_add_data_streaming_json(self): datastreamId = 'datstream-id' # id of the datasream which is live try: data = "time, tag, value " + "\n" + "2016-03-01 01:01:01, signal1_entity1, 3.4" + "\n" + "2016-03-01 01:01:01, signal2_entity1, 1.4" options = {'streaming': True, 'hasMoreData': False} response = self.fclient.add_input_data(datastreamId, 'json', options, data) self.assertNotEqual( response, 'Data Submitted Successfully', 'Cannot add historical input data to datastream') except Exception as e: # if response is "{"message":"Datastream is not live, streaming data cannot be accepted."}" Please turn on datastream first then add streaming data print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') # Add live input data (csv format) to Datastream (Used for live monitoring) @unittest.skip("Skipping streaming data ingestion") # Streaming data can only be sent to datastream of datastream is live. So make sure that datastream is live first def test_add_data_streaming_csv(self): datastreamId = 'datstream-id' # id of the datasream which is live try: data = '{"time" :"2016-03-01 01:01:01", "current" : 12.4, "vibration" : 3.4, "state" : "On"}' options = {'streaming': True, 'hasMoreData': False} response = self.fclient.add_input_data(datastreamId, 'json', options, data) self.assertNotEqual( response, 'Data Submitted Successfully', 'Cannot add historical input data to datastream') except Exception as e: # if response is "{"message":"Datastream is not live, streaming data cannot be accepted."}" Please turn on datastream first then add streaming data print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') # Add narrow input data (csv format) with batch identifier to multi thing Datastream def test_add_narrow_multi_thing_data_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") signal.set_signalIdentifier("signal") signal.set_valueIdentifier("value") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('unit') field.set_batchIdentifier('batchId') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # adding data to datastream data = 'time,batchId,unit,signal,value\n' \ '1,batch_1,unit1,signal1,9.95\n' \ '2,batch_1,unit1,signal1,4.45\n' \ '3,batch_2,unit1,signal1,1.45\n' \ '4,batch_2,unit1,signal1,8.45\n' \ '5,batch_2,unit1,signal1,2.45\n' \ '1,batch_1,unit1,signal2,19.95\n' \ '2,batch_1,unit1,signal2,14.45\n' \ '3,batch_2,unit1,signal2,10.45\n' \ '4,batch_2,unit1,signal2,18.45\n' \ '5,batch_2,unit1,signal2,12.45\n' \ '1,batch_1,unit1,signal3,39.95\n' \ '2,batch_1,unit1,signal3,34.45\n' \ '3,batch_2,unit1,signal3,30.45\n' \ '4,batch_2,unit1,signal3,38.45\n' \ '5,batch_2,unit1,signal3,32.45\n' options = {'streaming': False, 'hasMoreData': False} response = self.fclient.add_input_data( datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add narrow input data (json format) with batch identifier to single thing Datastream def test_add_narrow_single_thing_data_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") signal.set_signalIdentifier("inputs") signal.set_valueIdentifier("val") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_batchIdentifier('batches') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # adding data to datastream data = '{"time": 1,"batchId": "batch_1","signal": "signal1","value": 9.95}\n' \ '{"time": 2,"batchId": "batch_1","signal": "signal1","value": 4.45}\n' \ '{"time": 3,"batchId": "batch_2","signal": "signal1","value": 1.45}\n' \ '{"time": 4,"batchId": "batch_2","signal": "signal1","value": 8.45}\n' \ '{"time": 5,"batchId": "batch_2","signal": "signal1","value": 2.45}' options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'signalIdentifier': 'signal', 'valueIdentifier': 'value', 'batchIdentifier': 'batchId' } response = self.fclient.add_input_data( datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add wide input data (csv format) with batch identifier to multi thing Datastream def test_add_wide_multi_thing_data_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('unit') field.set_batchIdentifier('batchId') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = 'time,batchId,unit,signal1,signal2,signal3\n' \ '1,batch_1,unit1,9.95,19.95,39.95\n' \ '2,batch_1,unit1,4.45,14.45,34.45\n' \ '3,batch_2,unit1,1.45,10.45,30.45\n' \ '4,batch_2,unit1,8.45,18.45,38.45\n' \ '5,batch_2,unit1,2.45,12.45,32.45' options = {'streaming': False, 'hasMoreData': False} response = self.fclient.add_input_data( datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add wide input data (json format) with batch identifier to single thing Datastream def test_add_wide_single_thing_data_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_batchIdentifier('batches') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # adding data to datastream data = '{"time": 1,"batchId": "batch_1","signal1": 9.95,"signal2": 19.95,"signal3": 39.95}\n' \ '{"time": 2,"batchId": "batch_1","signal1": 4.45,"signal2": 14.45,"signal3": 34.45}\n' \ '{"time": 3,"batchId": "batch_2","signal1": 1.45,"signal2": 10.45,"signal3": 30.45}\n' \ '{"time": 4,"batchId": "batch_2","signal1": 8.45,"signal2": 18.45,"signal3": 38.45}\n' \ '{"time": 5,"batchId": "batch_2","signal1": 2.45,"signal2": 12.45,"signal3": 32.45}' options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'batchIdentifier': 'batchId' } response = self.fclient.add_input_data( datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') def tearDown(self): # teardown for ds in self.created_datastreams: try: self.fclient.delete_datastream(ds) except Exception as e: print(exception_handler(e)) pass
class TestAddDataStream(unittest.TestCase): def setUp(self): self.fclient = FClient(host=host, token=token, options=None) self.created_datastreams = [] pass # Add historical wide input data (json format) to single entity Datastream (Used for model revision) def test_add_historical_json_data_stream(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = io.open('./resources/data.json') options = {'streaming': False, 'hasMoreData':False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier()} # adding data to the datastream response = self.fclient.add_input_stream(datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add historical input data (csv format) from a stream to single entity Datastream (Used for model revision) def test_add_historical_csv_data_stream(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = io.open('./resources/data.csv') options = {'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier()} # adding data to datstream response = self.fclient.add_input_stream(datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add historical input data (csv format) from a stream to Multi entity Datastream (Used for model revision) def test_add_historical_csv_data_stream_multi(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = io.open('./resources/dataMultiEntity.csv') options = {'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'entityIdentifier': 'car', 'valueIdentifier': 'value', 'signalIdentifier': 'signal' } response = self.fclient.add_input_stream(datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add live input data (csv format) from a stream to Datastream (Used for live monitoring) @unittest.skip("streaming can only be done once ") # Streaming data can only be sent to datastream if datastream is live. So make sure that datastream is live first def test_add_streaming_csv_data_stream(self): datastreamId = 'datstream-id' # id of the datastream which is live try: data = io.open('./resources/data.csv') options = {'streaming': True, 'hasMoreData':False} response = self.fclient.add_input_data(datastreamId, 'csv', options, data) self.assertNotEqual(response, 'Data Submitted Successfully', 'Cannot add historical input data to datastream') except Exception as e: # if response is "{"message":"Datastream is not live, streaming data cannot be accepted."}" Please turn on datastream first then add streaming data print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') # Add live input data (json format) from a stream to Datastream (Used for live monitoring) @unittest.skip("streaming can only be done once ") # Streaming data can only be sent to datastream if datastream is live. So make sure that datastream is live first def test_add_streaming_json_data_stream(self): datastreamId = 'datstream-id' # id of the datastream which is live try: data = io.open('./resources/data.json') options = {'streaming': True, 'hasMoreData':False} response = self.fclient.add_input_data(datastreamId, 'json', options, data) self.assertNotEqual(response, 'Data Submitted Successfully', 'Cannot add historical input data to datastream') except Exception as e: # if response is "{"message":"Datastream is not live, streaming data cannot be accepted."}" Please turn on datastream first then add streaming data print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') def tearDown(self): # teardown for ds in self.created_datastreams: try: self.fclient.delete_datastream(ds) except Exception as e: print(exception_handler(e)) pass
def test_create_pipeline_for_single_thing_with_eventType(self): fclient = FClient(host=host, token=token) eventbuffer = Schemas.Eventbuffer() eventbuffer.set_name('Motor Health' + str(random.random())) eventbuffer.set_time_identifier('time') eventbuffer.set_time_format('iso_8601') try: eventbuffer = fclient.create_eventbuffer(eventbuffer) data = '{"time" :"2016-03-01 01:01:01", "current" : 12.4, "vibration" : 3.4, "state" : "On"}' try: response = fclient.add_input_data(eventbuffer.get_id(), 'json', {}, data) pipeline = Schemas.Pipeline() signals = { 'current': ['Numeric', 'Occurrences'], 'vibration': ['Numeric', 'Samples'], 'state': 'Categorical' } assessment = Schemas.Assessment() assessment.set_name('Health') \ .set_input_signals(['current', 'vibration', 'state']) pipeline.set_name('Motor Health 1') \ .set_eventbuffer(eventbuffer.get_id()) \ .set_input_signals(signals) \ .set_assessment(assessment) try: response = fclient.create_pipeline(pipeline) self.assertEqual(isinstance(response, Schemas.Pipeline), True, 'Invalid Pipeline object after creation') self.assertEqual(isinstance(response.get_id(), unicode), True, 'Invalid Pipeline object after creation') self.assertEqual(response.get_name(), pipeline.get_name(), 'Invalid Pipeline object after creation') self.assertNotEqual( response.get_thing_name(), None, 'Invalid Pipeline object after creation') self.assertEqual(len(response.get_input_signals()), 3, 'Invalid Pipeline object after creation') self.assertEqual(len(response.get_assessments()), 1, 'Invalid Pipeline object after creation') self.assertEqual(response.get_eventbuffer(), eventbuffer.get_id(), 'Invalid Pipeline object after creation') # tear down try: fclient.delete_pipeline(response.get_id()) fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass except Exception as e: print(e.message) try: fclient.delete_eventbuffer(eventbuffer.get_id()) except Exception as e: pass self.assertEqual(0, 1, 'Cannot create pipeline') except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot add data') except Exception as e: print(e.message) self.assertEqual(0, 1, 'Cannot create eventbuffer')
class TestAddData(unittest.TestCase): def setUp(self): self.fclient = FClient(host=host, token=token, options=None) self.created_datastreams = [] pass # Add narrow input data (json format) to multi entity Datastream def test_add_data_json_mutli(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") signal.set_signalIdentifier("signal") signal.set_valueIdentifier("value") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = '{"time" : "2016-03-01 01:01:01", "signal" : "current", "value" : 12.4, "car" : "unit1"}' options = {'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'signalIdentifier': 'signal', 'valueIdentifier': 'value', 'entityIdentifier': 'car'} # adding data to the created datastream response = self.fclient.add_input_data(datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add narrow input data (csv format) to single entity to Datastream def test_add_data_csv_single(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() signal.set_valueIdentifier("value") signal.set_signalIdentifier("signal") time.set_zone("GMT") time.set_identifier("time") time.set_format("iso_8601") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # input data has timeformat different than the one set while creating datastream data = "time, signal, value " + "\n" + "2016-03-01 01:01:01, signal1, 3.4" + "\n" + "2016-03-01 01:01:01, signal2, 1.4" options = {'streaming': False, 'hasMoreData': False, 'timeFormat': "YYYY-MM-DD HH:mm:ss", 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier()} response = self.fclient.add_input_data(datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add wide input data (json format) to single entity Datastream def test_add_data_json_single(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityName('machine') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # adding data to datastream data = '{"time" :"2016-03-01 01:01:01", "current" : 12.4, "vibration" : 3.4, "state" : "On"}' options = {'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'entityName': 'machine'} response = self.fclient.add_input_data(datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add wide input data (csv format) to multi entity Datastream def test_add_data_csv_multi(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = "time,current,vibrarion,state,car" + "\n" + "2016-03-01 01:01:01,12.4,3.4,on,car1" + "\n" + "2016-03-01 01:01:01,31.2,1.4,off,car1" + "\n" + "2016-03-01 01:01:01,24,3.2,on,car2" + "\n" + "2016-03-01 01:01:01,31,3.4,off,car2" options = {'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'entityIdentifier': 'car'} response = self.fclient.add_input_data(datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Cannot add data due to missing time Identifer def test_add_data_csv_multi_miss_time_identifier(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = "time,current,vibrarion,state,car" + "\n" + "2016-03-01 01:01:01,12.4,3.4,on,car1" + "\n" + "2016-03-01 01:01:01,31.2,1.4,off,car1" + "\n" + "2016-03-01 01:01:01,24,3.2,on,car2" + "\n" + "2016-03-01 01:01:01,31,3.4,off,car2" options = {'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'entityIdentifier': 'car'} response = self.fclient.add_input_data(datastreamResponse.get_id(), 'csv', options, data) self.assertEqual(0, 1, 'Missing time identifer error not caught') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: # Printing only for debugging purposes print("\nResponse :", exception_handler(e)) self.assertEqual(exception_handler(e), "Missing time identifier.", 'Missing time identifer error not caught') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Cannot add data due to missing time zone def test_add_data_csv_multi_miss_time_zone(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = "time,current,vibrarion,state,car" + "\n" + "2016-03-01 01:01:01,12.4,3.4,on,car1" + "\n" + "2016-03-01 01:01:01,31.2,1.4,off,car1" + "\n" + "2016-03-01 01:01:01,24,3.2,on,car2" + "\n" + "2016-03-01 01:01:01,31,3.4,off,car2" options = {'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeIdentifier': time.get_identifier(), 'entityIdentifier': 'car'} response = self.fclient.add_input_data(datastreamResponse.get_id(), 'csv', options, data) self.assertEqual(0, 1, 'Missing time zone error not caught') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: # (b'{"message":"Missing time zone."}',) print("\nResponse :",exception_handler(e)) self.assertEqual(exception_handler(e), "Missing time zone.", 'Missing time zone error not caught') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Cannot add data due to missing time format def test_add_data_csv_multi_miss_time_format(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('car') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = "time,current,vibrarion,state,car" + "\n" + "2016-03-01 01:01:01,12.4,3.4,on,car1" + "\n" + "2016-03-01 01:01:01,31.2,1.4,off,car1" + "\n" + "2016-03-01 01:01:01,24,3.2,on,car2" + "\n" + "2016-03-01 01:01:01,31,3.4,off,car2" options = {'streaming': False, 'hasMoreData': False, 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'entityIdentifier': 'car'} response = self.fclient.add_input_data(datastreamResponse.get_id(), 'csv', options, data) self.assertEqual(0, 1, 'Missing time format error not caught') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: # Printing only for debugging purposes print('\nResponse :',exception_handler(e)) self.assertEqual(exception_handler(e), "Missing time format.", 'Missing time format error not caught') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add live input data (json format) to Datastream (Used for live monitoring) @unittest.skip("Skipping streaming data ingestion") # Streaming data can only be sent to datastream if datastream is live. So make sure that datastream is live first def test_add_data_streaming_json(self): datastreamId = 'datstream-id' # id of the datasream which is live try: data = "time, tag, value " + "\n" + "2016-03-01 01:01:01, signal1_entity1, 3.4" + "\n" + "2016-03-01 01:01:01, signal2_entity1, 1.4" options = {'streaming': True, 'hasMoreData':False} response = self.fclient.add_input_data(datastreamId, 'json', options, data) self.assertNotEqual(response, 'Data Submitted Successfully', 'Cannot add historical input data to datastream') except Exception as e: # if response is "{"message":"Datastream is not live, streaming data cannot be accepted."}" Please turn on datastream first then add streaming data print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') # Add live input data (csv format) to Datastream (Used for live monitoring) @unittest.skip("Skipping streaming data ingestion") # Streaming data can only be sent to datastream of datastream is live. So make sure that datastream is live first def test_add_data_streaming_csv(self): datastreamId = 'datstream-id' # id of the datasream which is live try: data = '{"time" :"2016-03-01 01:01:01", "current" : 12.4, "vibration" : 3.4, "state" : "On"}' options = {'streaming': True, 'hasMoreData':False} response = self.fclient.add_input_data(datastreamId, 'json', options, data) self.assertNotEqual(response, 'Data Submitted Successfully', 'Cannot add historical input data to datastream') except Exception as e: # if response is "{"message":"Datastream is not live, streaming data cannot be accepted."}" Please turn on datastream first then add streaming data print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') # Add narrow input data (csv format) with batch identifier to multi thing Datastream def test_add_narrow_multi_thing_data_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") signal.set_signalIdentifier("signal") signal.set_valueIdentifier("value") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('unit') field.set_batchIdentifier('batchId') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # adding data to datastream data = 'time,batchId,unit,signal,value\n' \ '1,batch_1,unit1,signal1,9.95\n' \ '2,batch_1,unit1,signal1,4.45\n' \ '3,batch_2,unit1,signal1,1.45\n' \ '4,batch_2,unit1,signal1,8.45\n' \ '5,batch_2,unit1,signal1,2.45\n' \ '1,batch_1,unit1,signal2,19.95\n' \ '2,batch_1,unit1,signal2,14.45\n' \ '3,batch_2,unit1,signal2,10.45\n' \ '4,batch_2,unit1,signal2,18.45\n' \ '5,batch_2,unit1,signal2,12.45\n' \ '1,batch_1,unit1,signal3,39.95\n' \ '2,batch_1,unit1,signal3,34.45\n' \ '3,batch_2,unit1,signal3,30.45\n' \ '4,batch_2,unit1,signal3,38.45\n' \ '5,batch_2,unit1,signal3,32.45\n' options = { 'streaming': False, 'hasMoreData': False } response = self.fclient.add_input_data(datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add narrow input data (json format) with batch identifier to single thing Datastream def test_add_narrow_single_thing_data_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") signal.set_signalIdentifier("inputs") signal.set_valueIdentifier("val") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_batchIdentifier('batches') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # adding data to datastream data = '{"time": 1,"batchId": "batch_1","signal": "signal1","value": 9.95}\n' \ '{"time": 2,"batchId": "batch_1","signal": "signal1","value": 4.45}\n' \ '{"time": 3,"batchId": "batch_2","signal": "signal1","value": 1.45}\n' \ '{"time": 4,"batchId": "batch_2","signal": "signal1","value": 8.45}\n' \ '{"time": 5,"batchId": "batch_2","signal": "signal1","value": 2.45}' options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'signalIdentifier': 'signal', 'valueIdentifier': 'value', 'batchIdentifier': 'batchId' } response = self.fclient.add_input_data(datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add wide input data (csv format) with batch identifier to multi thing Datastream def test_add_wide_multi_thing_data_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier('unit') field.set_batchIdentifier('batchId') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: data = 'time,batchId,unit,signal1,signal2,signal3\n' \ '1,batch_1,unit1,9.95,19.95,39.95\n' \ '2,batch_1,unit1,4.45,14.45,34.45\n' \ '3,batch_2,unit1,1.45,10.45,30.45\n' \ '4,batch_2,unit1,8.45,18.45,38.45\n' \ '5,batch_2,unit1,2.45,12.45,32.45' options = { 'streaming': False, 'hasMoreData': False } response = self.fclient.add_input_data(datastreamResponse.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') # Add wide input data (json format) with batch identifier to single thing Datastream def test_add_wide_single_thing_data_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_batchIdentifier('batches') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # adding data to datastream data = '{"time": 1,"batchId": "batch_1","signal1": 9.95,"signal2": 19.95,"signal3": 39.95}\n' \ '{"time": 2,"batchId": "batch_1","signal1": 4.45,"signal2": 14.45,"signal3": 34.45}\n' \ '{"time": 3,"batchId": "batch_2","signal1": 1.45,"signal2": 10.45,"signal3": 30.45}\n' \ '{"time": 4,"batchId": "batch_2","signal1": 8.45,"signal2": 18.45,"signal3": 38.45}\n' \ '{"time": 5,"batchId": "batch_2","signal1": 2.45,"signal2": 12.45,"signal3": 32.45}' options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'batchIdentifier': 'batchId' } response = self.fclient.add_input_data(datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') def tearDown(self): # teardown for ds in self.created_datastreams: try: self.fclient.delete_datastream(ds) except Exception as e: print(exception_handler(e)) pass
class TestAddFacts(unittest.TestCase): def setUp(self): self.fclient = FClient(host=host, token=token, options=None) self.created_datastreams = [] pass # Add facts data (json format) to Assessment def test_add_json_facts(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_entityIdentifier("car") datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment(asmtRequest) # adding fact data = '{"time" : "2011-03-26T12:00:00.000Z", "car" : "HI3821", "end" : "2012-06-01T00:00:00.000Z", "Health" : "Normal"}' options = { 'startTimeIdentifier': "time", 'endTimeIdentifier': "end", 'timeFormat': "iso_8601", 'timeZone': time.get_zone(), 'entityIdentifier': "car", 'valueIdentifier': "Health" } response = self.fclient.add_facts(resp_assessment.get_id(), 'json', options, data) # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, "Cannot create datastream") # Add facts data (csv format) to Assessment def test_add_csv_facts(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment(asmtRequest) # adding fact to the assessment data = "time,end,car,Health\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,IL9753,Normal\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,HI3821,Normal" options = { 'startTimeIdentifier': "time", 'endTimeIdentifier': "end", 'timeFormat': "iso_8601", 'timeZone': time.get_zone(), 'valueIdentifier': "Health" } response = self.fclient.add_facts(resp_assessment.get_id(), 'csv', options, data) # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, "Cannot create datastream") # Add facts data (csv format) with tags to Assessment def test_add_csv_facts_with_tags(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment(asmtRequest) data = "time,end,car,Health,Tags\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,IL9753,Normal,testTag1\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,HI3821,Normal,testTag2" options = { 'startTimeIdentifier': "time", 'endTimeIdentifier': "end", 'timeFormat': "iso_8601", 'timeZone': time.get_zone(), 'valueIdentifier': "Health", 'keywordIdentifier': 'Tags' } # adding fact response = self.fclient.add_facts(resp_assessment.get_id(), 'csv', options, data) # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, "Cannot create datastream") # Add facts data (csv format) with additional Tag to Assessment def test_add_csv_facts_with_additional_tags(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("YYYY-MM-DD HH:mm:ss") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment(asmtRequest) data = "time,end,car,Health\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,IL9753,Normal\n2011-03-31T00:00:00.000Z,2011-04-01T00:00:00.000Z,HI3821,Normal" options = { 'startTimeIdentifier': "time", 'endTimeIdentifier': "end", 'timeFormat': "iso_8601", 'timeZone': time.get_zone(), 'valueIdentifier': "Health", 'additionalKeyword': 'testTag' } response = self.fclient.add_facts(resp_assessment.get_id(), 'csv', options, data) # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, "Cannot create datastream") # Add facts data (csv format) with batch identifier to Assessment def test_add_csv_fact_with_batch(self): # creating datastream datastream = Schemas.Datastream() datastream.set_name('Motor Health' + str(random.random())) datasource = Schemas.Datasource() field = Schemas.Field() time = Schemas.Time() signal = Schemas.Signal() time.set_zone("GMT") time.set_identifier("time") time.set_format("millis") field.set_signal(signal) datasource.set_type("STANDALONE") field.set_time(time) field.set_batchIdentifier('batches') datastream.set_datasource(datasource) datastream.set_field(field) try: datastreamResponse = self.fclient.create_datastream(datastream) self.created_datastreams.append(datastreamResponse.get_id()) try: # creating assessment asmtRequest = Schemas.AssessmentRequest() asmtRequest.set_name('Assessment Name ' + str(random.random())) asmtRequest.set_datastream(datastreamResponse.get_id()) asmtRequest.set_rate('PT0S') try: resp_assessment = self.fclient.create_assessment(asmtRequest) data = '{"time" : 123898422222, "batches" : "batch_1", "signal" : "current", "value" : 12.4}\n' \ '{"time" : 123898422322, "batches" : "batch_2", "signal" : "current", "value" : 12.4}' options = { 'streaming': False, 'hasMoreData': False, 'timeFormat': time.get_format(), 'timeZone': time.get_zone(), 'timeIdentifier': time.get_identifier(), 'signalIdentifier': 'signal', 'valueIdentifier': 'value', 'batchIdentifier': 'batches' } # adding data to the created datastream response = self.fclient.add_input_data(datastreamResponse.get_id(), 'json', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add input data to datastream') # checking if data got ingested check_data_ingestion(self, response) # adding fact to the assessment data = "batchId,value\n" \ "batch_1,normal\n" \ "batch_2,abnormal" options = { 'valueIdentifier': "value", 'batchIdentifier': 'batchId' } response = self.fclient.add_facts(resp_assessment.get_id(), 'csv', options, data) self.assertNotEqual(response['__$id'], None, 'Cannot add fact data to datastream') # checking if data got ingested check_data_ingestion(self, response) except Exception as e: print(exception_handler(e)) try: self.fclient.delete_datastream(datastreamResponse.get_id()) except Exception as e: pass self.assertEqual(0, 1, 'Cannot create assessment') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot add input or fact data to datastream') except Exception as e: print(exception_handler(e)) self.assertEqual(0, 1, 'Cannot create datastream') def tearDown(self): # teardown for ds in self.created_datastreams: try: self.fclient.delete_datastream(ds) except Exception as e: print(exception_handler(e)) pass