public void Run(RegressionEnvironment env)
{
var fields = "name,favorite_number,favorite_color";
env.CompileDeploy("@Name('s0') select " + fields + " from User").AddListener("s0");
var schema =
AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("User"));
var eventOneJson = "{\"name\": \"Jane\", \"favorite_number\": 256, \"favorite_color\": \"red\"}";
var record = Parse(schema, eventOneJson);
env.SendEventAvro(record, "User");
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields.SplitCsv(),
new object[] {"Jane", 256, "red"});
var eventTwoJson = "{\"name\": \"Hans\", \"favorite_number\": -1, \"favorite_color\": \"green\"}";
record = Parse(schema, eventTwoJson);
env.SendEventAvro(record, "User");
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields.SplitCsv(),
new object[] {"Hans", -1, "green"});
env.UndeployAll();
}
private void RunAvroType(
RegressionEnvironment env,
RegressionPath path)
{
// Avro
var schema = AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME));
var innerSchema = schema.GetField("Nested").Schema;
var avroInner = new GenericRecord(innerSchema.AsRecordSchema());
avroInner.Put("MyInsideInt", 10);
var avro = new GenericRecord(schema.AsRecordSchema());
avro.Put("MyInt", 1);
avro.Put("MyString", "abc");
avro.Put("Nested", avroInner);
RunAssertion(env, AVRO_TYPENAME, FAVRO, avro, path);
}
public void Run(RegressionEnvironment env)
{
var path = new RegressionPath();
RunAssertion(
env,
BEAN_TYPE.Name,
FBEAN,
new MyIMEvent(new string[] { "v1", "v2" }, Collections.SingletonDataMap("k1", "v1")),
path);
RunAssertion(
env,
MAP_TYPENAME,
FMAP,
TwoEntryMap <string, object>("Indexed", new string[] { "v1", "v2" }, "Mapped", Collections.SingletonDataMap("k1", "v1")),
path);
RunAssertion(env, OA_TYPENAME, FOA, new object[] { new string[] { "v1", "v2" }, Collections.SingletonDataMap("k1", "v1") }, path);
// Avro
var avroSchema = AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME)).AsRecordSchema();
var datum = new GenericRecord(avroSchema);
datum.Put("Indexed", Arrays.AsList("v1", "v2"));
datum.Put("Mapped", Collections.SingletonMap("k1", "v1"));
RunAssertion(env, AVRO_TYPENAME, FAVRO, datum, path);
// Json
var mapType = typeof(IDictionary <string, object>).CleanName();
env.CompileDeploy($"@public @buseventtype @name('schema') create json schema {JSON_TYPENAME} (Indexed string[], Mapped `{mapType}`)", path);
var json = "{\"Mapped\":{\"k1\":\"v1\"},\"Indexed\":[\"v1\",\"v2\"]}";
RunAssertion(env, JSON_TYPENAME, FJSON, json, path);
// Json+ProvidedClass
env.CompileDeploy(
$"@public @buseventtype @name('schema') @JsonSchema(ClassName='{typeof(MyLocalJsonProvided).FullName}') " +
$"create json schema {JSONPROVIDED_TYPENAME}()",
path);
RunAssertion(env, JSONPROVIDED_TYPENAME, FJSON, json, path);
}
public void Run(RegressionEnvironment env)
{
var path = new RegressionPath();
env.CompileDeploy("@Name('NamedWindow') create window MyWindow#keepall as MyEventWSchema", path);
env.CompileDeploy("insert into MyWindow select * from MyEventWSchema", path);
env.CompileDeploy("on SupportBean thebean update MyWindow set sb = thebean", path);
var schema = AvroSchemaUtil
.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("MyEventWSchema"))
.AsRecordSchema();
var @event = new GenericRecord(schema);
env.SendEventAvro(@event, "MyEventWSchema");
env.SendEventBean(new SupportBean("E1", 10));
var eventBean = env.GetEnumerator("NamedWindow").Advance();
Assert.AreEqual(
"{\"sb\":{\"SupportBeanSchema\":{\"TheString\":\"E1\",\"IntPrimitive\":10}}}",
SupportAvroUtil.AvroToJson(eventBean));
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
// schema from statement
var epl = "@Name('s0') " +
EventRepresentationChoice.AVRO.GetAnnotationText() +
"select 1 as carId, 'abc' as carType from SupportBean";
env.CompileDeploy(epl);
var schema = (Schema) ((AvroSchemaEventType) env.Statement("s0").EventType).Schema;
var schemaJson = schema.ToJsonObject();
Assert.AreEqual(
"{\"type\":\"record\",\"name\":\"stmt0_out0\",\"fields\":[{\"name\":\"carId\",\"type\":\"int\"},{\"name\":\"carType\",\"type\":{\"type\":\"string\",\"avro.string\":\"string\"}}]}",
schemaJson.ToString(Newtonsoft.Json.Formatting.None));
env.UndeployAll();
// schema to-string Avro
var schemaTwo = SchemaBuilder.Record(
"MyAvroEvent",
RequiredInt("carId"),
Field(
"carType",
StringType(
Property(PROP_STRING_KEY, PROP_STRING_VALUE))));
Assert.AreEqual(
"{\"type\":\"record\",\"name\":\"MyAvroEvent\",\"fields\":[{\"name\":\"carId\",\"type\":\"int\"},{\"name\":\"carType\",\"type\":{\"type\":\"string\",\"avro.string\":\"string\"}}]}",
schemaTwo.ToJsonObject().ToString(Newtonsoft.Json.Formatting.None));
env.UndeployAll();
env.CompileDeploy("@Name('s0') select count(*) from CarLocUpdateEvent(direction = 1)#time(1 min)")
.AddListener("s0");
var schemaCarLocUpd = AvroSchemaUtil
.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("CarLocUpdateEvent"))
.AsRecordSchema();
var @event = new GenericRecord(schemaCarLocUpd);
@event.Put("carId", "A123456");
@event.Put("direction", 1);
env.SendEventAvro(@event, "CarLocUpdateEvent");
Assert.AreEqual(1L, env.Listener("s0").AssertOneGetNewAndReset().Get("count(*)"));
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var notExists = MultipleNotExists(6);
// Bean
var inner = SupportBeanComplexProps.MakeDefaultBean();
Pair<object, object>[] beanTests = {
new Pair<object, object>(new SupportBeanDynRoot("xxx"), notExists),
new Pair<object, object>(
new SupportBeanDynRoot(inner),
AllExist(
inner.GetIndexed(0),
inner.GetIndexed(1),
inner.ArrayProperty[1],
inner.GetMapped("keyOne"),
inner.GetMapped("keyTwo"),
inner.MapProperty.Get("xOne")))
};
RunAssertion(env, BEAN_TYPE.Name, FBEAN, null, beanTests, typeof(object));
// Map
IDictionary<string, object> mapNestedOne = new Dictionary<string, object>();
mapNestedOne.Put("Indexed", new[] {1, 2});
mapNestedOne.Put("ArrayProperty", null);
mapNestedOne.Put("Mapped", TwoEntryMap("keyOne", 100, "keyTwo", 200));
mapNestedOne.Put("MapProperty", null);
var mapOne = Collections.SingletonDataMap("Item", mapNestedOne);
Pair<object, object>[] mapTests = {
new Pair<object, object>(Collections.EmptyDataMap, notExists),
new Pair<object, object>(
mapOne,
new[] {Exists(1), Exists(2), NotExists(), Exists(100), Exists(200), NotExists()})
};
RunAssertion(env, MAP_TYPENAME, FMAP, null, mapTests, typeof(object));
// Object-Array
object[] oaNestedOne = {
new[] {1, 2}, TwoEntryMap("keyOne", 100, "keyTwo", 200), new[] {1000, 2000},
Collections.SingletonMap("xOne", "abc")
};
object[] oaOne = {null, oaNestedOne};
Pair<object, object>[] oaTests = {
new Pair<object, object>(new object[] {null, null}, notExists),
new Pair<object, object>(oaOne, AllExist(1, 2, 2000, 100, 200, "abc"))
};
RunAssertion(env, OA_TYPENAME, FOA, null, oaTests, typeof(object));
// XML
Pair<object, object>[] xmlTests = {
new Pair<object, object>("", notExists),
new Pair<object, object>(
"<Item>" +
"<Indexed>1</Indexed>" +
"<Indexed>2</Indexed>" +
"<Mapped Id=\"keyOne\">3</Mapped>" +
"<Mapped Id=\"keyTwo\">4</Mapped>" +
"</Item>",
new[] {Exists("1"), Exists("2"), NotExists(), Exists("3"), Exists("4"), NotExists()})
};
RunAssertion(env, XML_TYPENAME, FXML, xmlToValue, xmlTests, typeof(XmlNode));
// Avro
var schema = AvroSchemaUtil
.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME))
.AsRecordSchema();
var itemSchema = AvroSchemaUtil
.FindUnionRecordSchemaSingle(schema.GetField("Item").Schema)
.AsRecordSchema();
var datumOne = new GenericRecord(schema);
datumOne.Put("Item", null);
var datumItemTwo = new GenericRecord(itemSchema);
datumItemTwo.Put("Indexed", Arrays.AsList(1, 2));
datumItemTwo.Put("Mapped", TwoEntryMap("keyOne", 3, "keyTwo", 4));
var datumTwo = new GenericRecord(schema);
datumTwo.Put("Item", datumItemTwo);
Pair<object, object>[] avroTests = {
new Pair<object, object>(new GenericRecord(schema), notExists),
new Pair<object, object>(datumOne, notExists),
new Pair<object, object>(
datumTwo,
new[] {Exists(1), Exists(2), NotExists(), Exists(3), Exists(4), NotExists()})
};
RunAssertion(env, AVRO_TYPENAME, FAVRO, null, avroTests, typeof(object));
}
public void Run(RegressionEnvironment env)
{
var path = new RegressionPath();
// Bean
var beanTests = new Pair <object, object>[] {
new Pair <object, object>(new SupportMarkerImplA("e1"), Exists("e1")),
new Pair <object, object>(new SupportMarkerImplB(1), Exists(1)),
new Pair <object, object>(new SupportMarkerImplC(), NotExists())
};
RunAssertion(env, nameof(SupportMarkerInterface), FBEAN, null, beanTests, typeof(object), path);
// Map
var mapTests = new Pair <object, object>[] {
new Pair <object, object>(Collections.SingletonMap("somekey", "10"), NotExists()),
new Pair <object, object>(Collections.SingletonMap("Id", "abc"), Exists("abc")),
new Pair <object, object>(Collections.SingletonMap("Id", 10), Exists(10)),
};
RunAssertion(env, MAP_TYPENAME, FMAP, null, mapTests, typeof(object), path);
// Object-Array
var oaTests = new Pair <object, object>[] {
new Pair <object, object>(new object[] { 1, null }, Exists(null)),
new Pair <object, object>(new object[] { 2, "abc" }, Exists("abc")),
new Pair <object, object>(new object[] { 3, 10 }, Exists(10)),
};
RunAssertion(env, OA_TYPENAME, FOA, null, oaTests, typeof(object), path);
// XML
var xmlTests = new Pair <object, object>[] {
new Pair <object, object>("", NotExists()),
new Pair <object, object>("<Id>10</Id>", Exists("10")),
new Pair <object, object>("<Id>abc</Id>", Exists("abc")),
};
RunAssertion(env, XML_TYPENAME, FXML, xmlToValue, xmlTests, typeof(XmlNode), path);
// Avro
var avroSchema = AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME)).AsRecordSchema();
var datumEmpty = new GenericRecord(SchemaBuilder.Record(AVRO_TYPENAME));
var datumOne = new GenericRecord(avroSchema);
datumOne.Put("Id", 101);
var datumTwo = new GenericRecord(avroSchema);
datumTwo.Put("Id", null);
var avroTests = new Pair <object, object>[] {
new Pair <object, object>(datumEmpty, NotExists()),
new Pair <object, object>(datumOne, Exists(101)),
new Pair <object, object>(datumTwo, Exists(null))
};
RunAssertion(env, AVRO_TYPENAME, FAVRO, null, avroTests, typeof(object), path);
// Json
env.CompileDeploy("@JsonSchema(Dynamic=true) @public @buseventtype create json schema " + JSON_TYPENAME + "()", path);
var jsonTests = new Pair <object, object>[] {
new Pair <object, object>("{}", NotExists()),
new Pair <object, object>("{\"Id\": 10}", Exists(10)),
new Pair <object, object>("{\"Id\": \"abc\"}", Exists("abc"))
};
RunAssertion(env, JSON_TYPENAME, FJSON, null, jsonTests, typeof(object), path);
}
public void Run(RegressionEnvironment env)
{
RegressionPath path = new RegressionPath();
// Bean
RunAssertionConversionImplicitType(
env,
path,
"Bean",
"SupportBean",
"ConvertEvent",
typeof(BeanEventType),
typeof(SupportBean),
"SupportMarketDataBean",
new SupportMarketDataBean("ACME", 0, 0L, null),
FBEANWTYPE,
"TheString".SplitCsv(),
new object[] {"ACME"});
// Map
IDictionary<string, object> mapEventOne = new Dictionary<string, object>();
mapEventOne.Put("one", "1");
mapEventOne.Put("two", "2");
RunAssertionConversionImplicitType(
env,
path,
"Map",
"MapOne",
"ConvertEventMap",
typeof(WrapperEventType),
typeof(IDictionary<string, object>),
"MapTwo",
mapEventOne,
FMAPWTYPE,
"one,two".SplitCsv(),
new object[] {"1", "|2|"});
IDictionary<string, object> mapEventTwo = new Dictionary<string, object>();
mapEventTwo.Put("one", "3");
mapEventTwo.Put("two", "4");
RunAssertionConversionConfiguredType(
env,
path,
"MapOne",
"ConvertEventMap",
"MapTwo",
typeof(MappedEventBean),
typeof(Dictionary<string, object>),
mapEventTwo,
FMAPWTYPE,
"one,two".SplitCsv(),
new object[] {"3", "|4|"});
// Object-Array
RunAssertionConversionImplicitType(
env,
path,
"OA",
"OAOne",
"ConvertEventObjectArray",
typeof(WrapperEventType),
typeof(object[]),
"OATwo",
new object[] {"1", "2"},
FOAWTYPE,
"one,two".SplitCsv(),
new object[] {"1", "|2|"});
RunAssertionConversionConfiguredType(
env,
path,
"OAOne",
"ConvertEventObjectArray",
"OATwo",
typeof(ObjectArrayBackedEventBean),
typeof(object[]),
new object[] {"3", "4"},
FOAWTYPE,
"one,two".SplitCsv(),
new object[] {"3", "|4|"});
// Avro
var rowOne = new GenericRecord(
AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("AvroOne")).AsRecordSchema());
rowOne.Put("one", "1");
rowOne.Put("two", "2");
RunAssertionConversionImplicitType(
env,
path,
"Avro",
"AvroOne",
"ConvertEventAvro",
typeof(WrapperEventType),
typeof(GenericRecord),
"AvroTwo",
rowOne,
FAVROWTYPE,
"one,two".SplitCsv(),
new object[] {"1", "|2|"});
var avroSchema = AvroSchemaUtil
.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("AvroTwo"))
.AsRecordSchema();
var rowTwo = new GenericRecord(avroSchema);
rowTwo.Put("one", "3");
rowTwo.Put("two", "4");
RunAssertionConversionConfiguredType(
env,
path,
"AvroOne",
"ConvertEventAvro",
"AvroTwo",
typeof(AvroGenericDataBackedEventBean),
typeof(GenericRecord),
rowTwo,
FAVROWTYPE,
"one,two".SplitCsv(),
new object[] {"3", "|4|"});
// Json
env.CompileDeploy(
"@buseventtype @public create json schema JsonOne(one string, two string);\n" +
"@buseventtype @public create json schema JsonTwo(one string, two string);\n",
path);
var jsonOne = new JObject();
jsonOne.Add("one", "1");
jsonOne.Add("two", "2");
RunAssertionConversionImplicitType(
env,
path,
"Json",
"JsonOne",
"ConvertEventJson",
typeof(WrapperEventType),
typeof(JsonEventObject),
"JsonTwo",
jsonOne.ToString(),
FJSONWTYPE,
"one,two".SplitCsv(),
new object[] {"1", "|2|"});
var jsonTwo = new JObject();
jsonTwo.Add("one", "3");
jsonTwo.Add("two", "4");
RunAssertionConversionConfiguredType(
env,
path,
"JsonOne",
"ConvertEventJson",
"JsonTwo",
typeof(object),
typeof(object),
jsonTwo.ToString(),
FJSONWTYPE,
"one,two".SplitCsv(),
new object[] {"3", "|4|"});
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
// Bean
Pair<object, object>[] beanTests = {
new Pair<object, object>(
SupportBeanComplexProps.MakeDefaultBean(),
AllExist("Simple", "NestedValue", "NestedNestedValue")),
new Pair<object, object>(new SupportMarkerImplA("x"), NOT_EXISTS)
};
RunAssertion(env, BEAN_TYPE.Name, FBEAN, null, beanTests, typeof(object));
// Map
var mapNestedNestedOne = Collections.SingletonDataMap("NestedNestedValue", 101);
var mapNestedOne = TwoEntryMap<string, object>(
"NestedNested", mapNestedNestedOne,
"NestedValue", "abc");
var mapOne = TwoEntryMap<string, object>(
"SimpleProperty", 5,
"Nested", mapNestedOne);
Pair<object, object>[] mapTests = {
new Pair<object, object>(
Collections.SingletonDataMap("SimpleProperty", "a"),
new[] {Exists("a"), NotExists(), NotExists()}),
new Pair<object, object>(mapOne, AllExist(5, "abc", 101))
};
RunAssertion(env, MAP_TYPENAME, FMAP, null, mapTests, typeof(object));
// Object-Array
object[] oaNestedNestedOne = {101};
object[] oaNestedOne = {"abc", oaNestedNestedOne};
object[] oaOne = {5, oaNestedOne};
Pair<object, object>[] oaTests = {
new Pair<object, object>(new object[] {"a", null}, new[] {Exists("a"), NotExists(), NotExists()}),
new Pair<object, object>(oaOne, AllExist(5, "abc", 101))
};
RunAssertion(env, OA_TYPENAME, FOA, null, oaTests, typeof(object));
// XML
Pair<object, object>[] xmlTests = {
new Pair<object, object>(
"<SimpleProperty>abc</SimpleProperty>" +
"<Nested NestedValue=\"100\">\n" +
"\t<NestedNested NestedNestedValue=\"101\">\n" +
"\t</NestedNested>\n" +
"</Nested>\n",
AllExist("abc", "100", "101")),
new Pair<object, object>("<Nested/>", NOT_EXISTS)
};
RunAssertion(env, XML_TYPENAME, FXML, xmlToValue, xmlTests, typeof(XmlNode));
// Avro
var avroSchema = AvroSchemaUtil
.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME))
.AsRecordSchema();
var datumNull = new GenericRecord(avroSchema);
var schema = avroSchema;
var nestedSchema = AvroSchemaUtil
.FindUnionRecordSchemaSingle(schema.GetField("Nested").Schema)
.AsRecordSchema();
var nestedNestedSchema = AvroSchemaUtil
.FindUnionRecordSchemaSingle(nestedSchema.GetField("NestedNested").Schema)
.AsRecordSchema();
var nestedNestedDatum = new GenericRecord(nestedNestedSchema);
nestedNestedDatum.Put("NestedNestedValue", 101);
var nestedDatum = new GenericRecord(nestedSchema);
nestedDatum.Put("NestedValue", 100);
nestedDatum.Put("NestedNested", nestedNestedDatum);
var datumOne = new GenericRecord(schema);
datumOne.Put("SimpleProperty", "abc");
datumOne.Put("Nested", nestedDatum);
Pair<object, object>[] avroTests = {
new Pair<object, object>(
new GenericRecord(SchemaBuilder.Record(AVRO_TYPENAME)),
NOT_EXISTS),
new Pair<object, object>(datumNull, new[] {Exists(null), NotExists(), NotExists()}),
new Pair<object, object>(datumOne, AllExist("abc", 100, 101))
};
RunAssertion(env, AVRO_TYPENAME, FAVRO, null, avroTests, typeof(object));
}
public void Run(RegressionEnvironment env)
{
var notExists = MultipleNotExists(4);
var path = new RegressionPath();
// Bean
var bean = SupportBeanComplexProps.MakeDefaultBean();
var beanTests = new Pair <object, object>[] {
new Pair <object, object>(
bean,
AllExist(bean.GetIndexed(0), bean.GetIndexed(1), bean.GetMapped("keyOne"), bean.GetMapped("keyTwo")))
};
RunAssertion(env, nameof(SupportBeanComplexProps), FBEAN, null, beanTests, typeof(object), path);
// Map
var mapTests = new Pair <object, object>[] {
new Pair <object, object>(Collections.SingletonMap("somekey", "10"), notExists),
new Pair <object, object>(
TwoEntryMap <string, object>(
"Indexed",
new int[] { 1, 2 },
"Mapped",
TwoEntryMap <string, object>("keyOne", 3, "keyTwo", 4)),
AllExist(1, 2, 3, 4)),
};
RunAssertion(env, MAP_TYPENAME, FMAP, null, mapTests, typeof(object), path);
// Object-Array
var oaTests = new Pair <object, object>[] {
new Pair <object, object>(new object[] { null, null }, notExists),
new Pair <object, object>(new object[] { new int[] { 1, 2 }, TwoEntryMap("keyOne", 3, "keyTwo", 4) }, AllExist(1, 2, 3, 4)),
};
RunAssertion(env, OA_TYPENAME, FOA, null, oaTests, typeof(object), path);
// XML
var xmlTests = new Pair <object, object>[] {
new Pair <object, object>("", notExists),
new Pair <object, object>(
"<Indexed>1</Indexed><Indexed>2</Indexed><Mapped id=\"keyOne\">3</Mapped><Mapped id=\"keyTwo\">4</Mapped>",
AllExist("1", "2", "3", "4"))
};
RunAssertion(env, XML_TYPENAME, FXML, xmlToValue, xmlTests, typeof(XmlNode), path);
// Avro
var schema = AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME)).AsRecordSchema();
var datumOne = new GenericRecord(SchemaBuilder.Record(AVRO_TYPENAME));
var datumTwo = new GenericRecord(schema);
datumTwo.Put("Indexed", Arrays.AsList(1, 2));
datumTwo.Put("Mapped", TwoEntryMap("keyOne", 3, "keyTwo", 4));
var avroTests = new Pair <object, object>[] {
new Pair <object, object>(datumOne, notExists),
new Pair <object, object>(datumTwo, AllExist(1, 2, 3, 4)),
};
RunAssertion(env, AVRO_TYPENAME, FAVRO, null, avroTests, typeof(object), path);
// Json
env.CompileDeploy("@JsonSchema(Dynamic=true) @public @buseventtype create json schema " + JSON_TYPENAME + "()", path);
var jsonTests = new Pair <object, object>[] {
new Pair <object, object>("{}", notExists),
new Pair <object, object>(
"{\"Mapped\":{\"keyOne\":\"3\",\"keyTwo\":\"4\"},\"Indexed\":[\"1\",\"2\"]}",
AllExist("1", "2", "3", "4"))
};
RunAssertion(env, JSON_TYPENAME, FJSON, null, jsonTests, typeof(object), path);
// Json-Provided-Class
var jsonProvidedTests = new Pair <object, object>[] {
new Pair <object, object>("{}", notExists),
new Pair <object, object>(
"{\"Mapped\":{\"keyOne\":\"3\",\"keyTwo\":\"4\"},\"Indexed\":[\"1\",\"2\"]}",
AllExist(1, 2, "3", "4"))
};
env.CompileDeploy(
"@JsonSchema(ClassName='" + typeof(MyLocalJsonProvided).FullName + "') @public @buseventtype create json schema " + JSONPROVIDED_TYPENAME + "()",
path);
RunAssertion(env, JSONPROVIDED_TYPENAME, FJSON, null, jsonProvidedTests, typeof(object), path);
}
public void Run(RegressionEnvironment env)
{
var path = new RegressionPath();
// Bean
RunAssertionSendEvent(env, path, "SupportBean", new SupportBean());
RunAssertionInvalid(
env,
"SupportBean",
new SupportBean_G("G1"),
"Event object of type " +
typeof(SupportBean_G).MaskTypeName() +
" does not equal, extend or implement the type " +
typeof(SupportBean).MaskTypeName() +
" of event type 'SupportBean'");
RunAssertionSendEvent(env, path, "SupportMarkerInterface", new SupportMarkerImplA("Q2"), new SupportBean_G("Q3"));
RunAssertionRouteEvent(env, path, "SupportBean", new SupportBean());
// Map
RunAssertionSendEvent(env, path, MAP_TYPENAME, new Dictionary <string, object>());
RunAssertionRouteEvent(env, path, MAP_TYPENAME, new Dictionary <string, object>());
RunAssertionInvalid(
env,
MAP_TYPENAME,
new SupportBean(),
"Unexpected event object of type " + typeof(SupportBean).MaskTypeName() + ", expected " + typeof(IDictionary <string, object>).CleanName());
// Object-Array
RunAssertionSendEvent(env, path, OA_TYPENAME, new object[] { });
RunAssertionRouteEvent(env, path, OA_TYPENAME, new object[] { });
RunAssertionInvalid(
env,
OA_TYPENAME,
new SupportBean(),
"Unexpected event object of type " + typeof(SupportBean).MaskTypeName() + ", expected Object[]");
// XML
RunAssertionSendEvent(env, path, XML_TYPENAME, SupportXML.GetDocument("<Myevent/>").DocumentElement);
RunAssertionRouteEvent(env, path, XML_TYPENAME, SupportXML.GetDocument("<Myevent/>").DocumentElement);
RunAssertionInvalid(
env,
XML_TYPENAME,
new SupportBean(),
"Unexpected event object type '" + typeof(SupportBean).MaskTypeName() + "' encountered, please supply a XmlDocument or XmlElement node");
RunAssertionInvalid(
env,
XML_TYPENAME,
SupportXML.GetDocument("<xxxx/>"),
"Unexpected root element name 'xxxx' encountered, expected a root element name of 'Myevent'");
// Avro
var schema = AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME))
.AsRecordSchema();
RunAssertionSendEvent(env, path, AVRO_TYPENAME, new GenericRecord(schema));
RunAssertionRouteEvent(env, path, AVRO_TYPENAME, new GenericRecord(schema));
RunAssertionInvalid(
env,
AVRO_TYPENAME,
new SupportBean(),
"Unexpected event object type '" + typeof(SupportBean).MaskTypeName() + "' encountered, please supply a GenericRecord");
// Json
var schemas = "@public @buseventtype @name('schema') create json schema " + JSON_TYPENAME + "()";
env.CompileDeploy(schemas, path);
RunAssertionSendEvent(env, path, JSON_TYPENAME, "{}");
RunAssertionRouteEvent(env, path, JSON_TYPENAME, "{}");
RunAssertionInvalid(
env,
JSON_TYPENAME,
new SupportBean(),
"Unexpected event object of type '" + typeof(SupportBean).Name + "', expected a Json-formatted string-type value");
// No such type
try {
env.EventService.GetEventSender("ABC");
Assert.Fail();
}
catch (EventTypeException ex) {
Assert.AreEqual("Event type named 'ABC' could not be found", ex.Message);
}
// Internal implicit wrapper type
env.CompileDeploy("insert into ABC select *, TheString as value from SupportBean");
try {
env.EventService.GetEventSender("ABC");
Assert.Fail("Event type named 'ABC' could not be found");
}
catch (EventTypeException ex) {
Assert.AreEqual("Event type named 'ABC' could not be found", ex.Message);
}
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var notExists = MultipleNotExists(6);
// Bean
var beanOne = SupportBeanComplexProps.MakeDefaultBean();
var n1v = beanOne.Nested.NestedValue;
var n1nv = beanOne.Nested.NestedNested.NestedNestedValue;
var beanTwo = SupportBeanComplexProps.MakeDefaultBean();
beanTwo.Nested.NestedValue = "nested1";
beanTwo.Nested.NestedNested.NestedNestedValue = "nested2";
Pair<object, object>[] beanTests = {
new Pair<object, object>(new SupportBeanDynRoot(beanOne), AllExist(n1v, n1v, n1nv, n1nv, n1nv, n1nv)),
new Pair<object, object>(
new SupportBeanDynRoot(beanTwo),
AllExist("nested1", "nested1", "nested2", "nested2", "nested2", "nested2")),
new Pair<object, object>(new SupportBeanDynRoot("abc"), notExists)
};
RunAssertion(env, "SupportBeanDynRoot", FBEAN, null, beanTests, typeof(object));
// Map
IDictionary<string, object> mapOneL2 = new Dictionary<string, object>();
mapOneL2.Put("NestedNestedValue", 101);
IDictionary<string, object> mapOneL1 = new Dictionary<string, object>();
mapOneL1.Put("NestedNested", mapOneL2);
mapOneL1.Put("NestedValue", 100);
IDictionary<string, object> mapOneL0 = new Dictionary<string, object>();
mapOneL0.Put("Nested", mapOneL1);
var mapOne = Collections.SingletonDataMap("Item", mapOneL0);
Pair<object, object>[] mapTests = {
new Pair<object, object>(mapOne, AllExist(100, 100, 101, 101, 101, 101)),
new Pair<object, object>(Collections.EmptyDataMap, notExists)
};
RunAssertion(env, MAP_TYPENAME, FMAP, null, mapTests, typeof(object));
// Object-Array
object[] oaOneL2 = {101};
object[] oaOneL1 = {oaOneL2, 100};
object[] oaOneL0 = {oaOneL1};
object[] oaOne = {oaOneL0};
Pair<object, object>[] oaTests = {
new Pair<object, object>(oaOne, AllExist(100, 100, 101, 101, 101, 101)),
new Pair<object, object>(new object[] {null}, notExists)
};
RunAssertion(env, OA_TYPENAME, FOA, null, oaTests, typeof(object));
// XML
Pair<object, object>[] xmlTests = {
new Pair<object, object>(
"<Item>\n" +
"\t<Nested NestedValue=\"100\">\n" +
"\t\t<NestedNested NestedNestedValue=\"101\">\n" +
"\t\t</NestedNested>\n" +
"\t</Nested>\n" +
"</Item>\n",
AllExist("100", "100", "101", "101", "101", "101")),
new Pair<object, object>("<item/>", notExists)
};
RunAssertion(env, XML_TYPENAME, FXML, xmlToValue, xmlTests, typeof(XmlNode));
// Avro
var schema =
AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME));
var nestedSchema =
AvroSchemaUtil.FindUnionRecordSchemaSingle(
schema
.GetField("Item")
.Schema.AsRecordSchema()
.GetField("Nested")
.Schema);
var nestedNestedSchema =
AvroSchemaUtil.FindUnionRecordSchemaSingle(
nestedSchema.GetField("NestedNested").Schema);
var nestedNestedDatum = new GenericRecord(nestedNestedSchema.AsRecordSchema());
nestedNestedDatum.Put("NestedNestedValue", 101);
var nestedDatum = new GenericRecord(nestedSchema.AsRecordSchema());
nestedDatum.Put("NestedValue", 100);
nestedDatum.Put("NestedNested", nestedNestedDatum);
var emptyDatum = new GenericRecord(SchemaBuilder.Record(AVRO_TYPENAME));
Pair<object, object>[] avroTests = {
new Pair<object, object>(nestedDatum, AllExist(100, 100, 101, 101, 101, 101)),
new Pair<object, object>(emptyDatum, notExists),
new Pair<object, object>(null, notExists)
};
RunAssertion(env, AVRO_TYPENAME, FAVRO, null, avroTests, typeof(object));
}
public void Run(RegressionEnvironment env)
{
EPStage stage = env.StageService.GetStage("ST");
RegressionPath path = new RegressionPath();
// Bean
RunAssertion(
env,
path,
stage,
"SupportBean",
new SupportBean(),
svc => svc.SendEventBean(new SupportBean(), "SupportBean"));
// Map
RunAssertion(
env,
path,
stage,
MAP_TYPENAME,
new Dictionary <string, object>(),
svc => svc.SendEventMap(new Dictionary <string, object>(), MAP_TYPENAME));
// Object-Array
RunAssertion(
env,
path,
stage,
OA_TYPENAME,
new object[0],
svc => svc.SendEventObjectArray(new object[0], OA_TYPENAME));
// XML
var node = SupportXML.GetDocument("<myevent/>").DocumentElement;
RunAssertion(
env,
path,
stage,
XML_TYPENAME,
node,
svc => svc.SendEventXMLDOM(node, XML_TYPENAME));
// Avro
var schema = AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME));
var record = new GenericRecord(schema.AsRecordSchema());
RunAssertion(
env,
path,
stage,
AVRO_TYPENAME,
record,
svc => svc.SendEventAvro(record, AVRO_TYPENAME));
// Json
RunAssertion(
env,
path,
stage,
JSON_TYPENAME,
"{}",
svc => svc.SendEventJson("{}", JSON_TYPENAME));
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var epl =
"@Name('bean') select * from " +
BEAN_TYPENAME +
";\n" +
"@Name('map') select * from " +
MAP_TYPENAME +
";\n" +
"@Name('oa') select * from " +
OA_TYPENAME +
";\n" +
"@Name('xml') select * from " +
XML_TYPENAME +
";\n" +
"@Name('avro') select * from " +
AVRO_TYPENAME +
";\n" +
"@public @buseventtype create json schema JsonEvent(Ident string);\n" +
"@Name('json') select * from JsonEvent;\n" +
"@Name('trigger') select * from SupportBean;";
env.CompileDeploy(epl)
.AddListener("map")
.AddListener("oa")
.AddListener("xml")
.AddListener("avro")
.AddListener("bean")
.AddListener("json");
env.Statement("trigger").Events += (
sender,
updateEventArgs) => {
var newEvents = updateEventArgs.NewEvents;
var processEvent = updateEventArgs.Runtime.EventService;
var ident = (string) newEvents[0].Get("TheString");
processEvent.RouteEventBean(new RoutedBeanEvent(ident), BEAN_TYPENAME);
processEvent.RouteEventMap(Collections.SingletonDataMap("Ident", ident), MAP_TYPENAME);
processEvent.RouteEventObjectArray(new object[] {ident}, OA_TYPENAME);
var xml = "<Myevent Ident=\"XXXXXX\"></Myevent>\n".Replace("XXXXXX", ident);
processEvent.RouteEventXMLDOM(SupportXML.GetDocument(xml).DocumentElement, XML_TYPENAME);
var avroSchema = AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME));
var datum = new GenericRecord(avroSchema.AsRecordSchema());
datum.Put("Ident", ident);
processEvent.RouteEventAvro(datum, AVRO_TYPENAME);
var jsonObject = new JObject(new JProperty("Ident", ident));
processEvent.RouteEventJson(jsonObject.ToString(), "JsonEvent");
};
env.SendEventBean(new SupportBean("xy", -1));
foreach (var name in new[] {"map", "bean", "oa", "xml", "avro", "json"}) {
var listener = env.Listener(name);
Assert.IsTrue(listener.IsInvoked, "failed for " + name);
Assert.AreEqual("xy", env.Listener(name).AssertOneGetNewAndReset().Get("Ident"));
}
env.UndeployAll();
}