private static void SendRepEvent( RegressionEnvironment env, EventRepresentationChoice rep, string name, string id, int p00) { if (rep.IsMapEvent()) { IDictionary<string, object> theEvent = new Dictionary<string, object>(); theEvent.Put("Id", id); theEvent.Put("P00", p00); env.SendEventMap(theEvent, name); } else if (rep.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {id, p00}, name); } else if (rep.IsAvroEvent()) { var theEvent = new GenericRecord( SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(name)) .AsRecordSchema()); theEvent.Put("Id", id); theEvent.Put("P00", p00); env.SendEventAvro(theEvent, name); } else if (rep.IsJsonEvent() || rep.IsJsonProvidedClassEvent()) { String json = "{\"Id\": \"" + id + "\", \"P00\": " + p00 + "}"; env.EventService.SendEventJson(json, name); } else { Assert.Fail(); } }
private static object SendEvent( RegressionEnvironment env, EventRepresentationChoice rep, string value) { object eventOne; if (rep.IsMapEvent()) { var @event = Collections.SingletonDataMap("col1", value); env.SendEventMap(@event, "MyEvent"); eventOne = @event; } else if (rep.IsObjectArrayEvent()) { var @event = new object[] {value}; env.SendEventObjectArray(@event, "MyEvent"); eventOne = @event; } else if (rep.IsAvroEvent()) { var schema = SupportAvroUtil.GetAvroSchema(env.Statement("schema").EventType).AsRecordSchema(); var @event = new GenericRecord(schema); @event.Put("col1", value); env.SendEventAvro(@event, "MyEvent"); eventOne = @event; } else if (rep.IsJsonEvent() || rep.IsJsonProvidedClassEvent()) { var @object = new JObject(new JProperty("col1", value)); env.SendEventJson(@object.ToString(), "MyEvent"); eventOne = @object.ToString(); } else { throw new IllegalStateException(); } return eventOne; }
private static void sendPortfolio( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum, string portfolio, string product) { if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {portfolio, product}, "Portfolio"); } else if (eventRepresentationEnum.IsMapEvent()) { var theEvent = new LinkedHashMap<string, object>(); theEvent.Put("portfolio", portfolio); theEvent.Put("product", product); env.SendEventMap(theEvent, "Portfolio"); } else if (eventRepresentationEnum.IsAvroEvent()) { var theEvent = new GenericRecord( SupportAvroUtil.GetAvroSchema( env.Runtime.EventTypeService.GetEventTypePreconfigured("Portfolio")) .AsRecordSchema()); theEvent.Put("portfolio", portfolio); theEvent.Put("product", product); env.EventService.SendEventAvro(theEvent, "Portfolio"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { var @object = new JObject(); @object.Add("portfolio", portfolio); @object.Add("product", product); env.EventService.SendEventJson(@object.ToString(), "Portfolio"); } else { Assert.Fail(); } }
private void MakeSendEvent( RegressionEnvironment env, string typeName, EventRepresentationChoice eventRepresentationEnum, object startTs, object endTs) { if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new[] {startTs, endTs}, typeName); } else if (eventRepresentationEnum.IsMapEvent()) { var theEvent = new Dictionary<string, object>(); theEvent.Put("startts", startTs); theEvent.Put("endts", endTs); env.SendEventMap(theEvent, typeName); } else if (eventRepresentationEnum.IsAvroEvent()) { var record = new GenericRecord( SupportAvroUtil.GetAvroSchema( env.Runtime.EventTypeService.GetEventTypePreconfigured(typeName)) .AsRecordSchema()); record.Put("startts", startTs); record.Put("endts", endTs); env.EventService.SendEventAvro(record, typeName); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { var json = "{\"startts\": \"" + startTs + "\", \"endts\": \"" + endTs + "\"}"; env.EventService.SendEventJson(json, typeName); } else { throw new IllegalStateException("Unrecognized enum " + eventRepresentationEnum); } }
private static void SendMySentenceEvent( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum, string sentence) { if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {sentence}, "MySentenceEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(Collections.SingletonDataMap("sentence", sentence), "MySentenceEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { var schema = SchemaBuilder.Record("sentence", TypeBuilder.RequiredString("sentence")); var record = new GenericRecord(schema); record.Put("sentence", sentence); env.SendEventAvro(record, "MySentenceEvent"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { var @object = new JObject(); @object.Add("sentence", sentence); env.SendEventJson(@object.ToString(), "MySentenceEvent"); } else { throw new IllegalStateException("Unrecognized enum " + eventRepresentationEnum); } }
private static void SendMyEvent( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum, string in1, int in2) { if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {in1, in2}, "MyEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { IDictionary<string, object> theEvent = new Dictionary<string, object>(); theEvent.Put("in1", in1); theEvent.Put("in2", in2); env.SendEventMap(theEvent, "MyEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { var theEvent = new GenericRecord( SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("MyEvent")) .AsRecordSchema()); theEvent.Put("in1", in1); theEvent.Put("in2", in2); env.EventService.SendEventAvro(theEvent, "MyEvent"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.EventService.SendEventJson("{\"in1\": \"" + in1 + "\", \"in2\": " + in2 + "}", "MyEvent"); } else { Assert.Fail(); } }
private static void RunTransposeMapAndObjectArray( RegressionEnvironment env, EventRepresentationChoice representation) { var fields = new[] {"p0", "p1"}; var path = new RegressionPath(); var schema = representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMySchema>() + "create schema MySchema(p0 string, p1 int)"; env.CompileDeployWBusPublicType(schema, path); string generateFunction; if (representation.IsObjectArrayEvent()) { generateFunction = "GenerateOA"; } else if (representation.IsMapEvent()) { generateFunction = "GenerateMap"; } else if (representation.IsAvroEvent()) { generateFunction = "GenerateAvro"; } else if (representation.IsJsonEvent() || representation.IsJsonProvidedClassEvent()) { generateFunction = "GenerateJson"; } else { throw new IllegalStateException("Unrecognized code " + representation); } var epl = "insert into MySchema select transpose(" + generateFunction + "(TheString, IntPrimitive)) from SupportBean"; env.CompileDeploy("@Name('s0') " + epl, path).AddListener("s0"); env.SendEventBean(new SupportBean("E1", 1)); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"E1", 1}); env.SendEventBean(new SupportBean("E2", 2)); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"E2", 2}); // MySchema already exists, start second statement env.CompileDeploy("@Name('s1') " + epl, path).AddListener("s1"); env.UndeployModuleContaining("s0"); env.SendEventBean(new SupportBean("E3", 3)); EPAssertionUtil.AssertProps( env.Listener("s1").AssertOneGetNewAndReset(), fields, new object[] {"E3", 3}); env.UndeployAll(); }
private static void RunAssertionCreateStreamTwo( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var path = new RegressionPath(); var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyEvent>() + " create schema MyEvent(myId int)\n;" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedAllMyEvent>() + " create schema AllMyEvent as (myEvent MyEvent, clazz String, reverse boolean);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSuspectMyEvent>() + " create schema SuspectMyEvent as (myEvent MyEvent, clazz String);\n"; env.CompileDeployWBusPublicType(epl, path); env.CompileDeploy( "@Name('s0') insert into AllMyEvent " + "select c as myEvent, 'test' as clazz, false as reverse " + "from MyEvent(myId=1) c", path) .AddListener("s0"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("s0").EventType.UnderlyingType)); env.CompileDeploy( "@Name('s1') insert into SuspectMyEvent " + "select c.myEvent as myEvent, clazz " + "from AllMyEvent(not reverse) c", path) .AddListener("s1"); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(MakeEvent(1).Values.ToArray(), "MyEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(MakeEvent(1), "MyEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { env.SendEventAvro(MakeEventAvro(1), "MyEvent"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.SendEventJson("{\"myId\": 1}", "MyEvent"); } else { Assert.Fail(); } AssertCreateStreamTwo(eventRepresentationEnum, env.Listener("s0").AssertOneGetNewAndReset(), env.Statement("s0")); AssertCreateStreamTwo(eventRepresentationEnum, env.Listener("s1").AssertOneGetNewAndReset(), env.Statement("s1")); env.UndeployAll(); }
private static void TryAssertionSplitPremptiveNamedWindow( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var path = new RegressionPath(); env.CompileDeployWBusPublicType( eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTrigger>() + " create schema TypeTrigger(trigger int)", path); env.CompileDeploy(eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTypeTwo>() + " create schema TypeTwo(col2 int)", path); env.CompileDeploy( eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTypeTwo>() + " create window WinTwo#keepall as TypeTwo", path); var stmtOrigText = "on TypeTrigger " + "insert into OtherStream select 1 " + "insert into WinTwo(col2) select 2 " + "output all"; env.CompileDeploy(stmtOrigText, path); env.CompileDeploy("@Name('s0') on OtherStream select col2 from WinTwo", path).AddListener("s0"); // populate WinOne env.SendEventBean(new SupportBean("E1", 2)); // fire trigger if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {null}, "TypeTrigger"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(new Dictionary<string, object>(), "TypeTrigger"); } else if (eventRepresentationEnum.IsAvroEvent()) { var @event = new GenericRecord( SchemaBuilder.Record("name", TypeBuilder.OptionalInt("trigger"))); env.SendEventAvro(@event, "TypeTrigger"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.SendEventJson("{}", "TypeTrigger"); } else { Assert.Fail(); } Assert.AreEqual(2, env.Listener("s0").AssertOneGetNewAndReset().Get("col2")); env.UndeployAll(); }
private static void SendOrderEvent( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum, string orderId, string productId, double price, int quantity, bool deletedFlag) { if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {orderId, productId, price, quantity, deletedFlag}, "OrderEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { IDictionary<string, object> theEvent = new LinkedHashMap<string, object>(); theEvent.Put("OrderId", orderId); theEvent.Put("ProductId", productId); theEvent.Put("Price", price); theEvent.Put("Quantity", quantity); theEvent.Put("DeletedFlag", deletedFlag); env.SendEventMap(theEvent, "OrderEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { var theEvent = new GenericRecord( SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("OrderEvent")) .AsRecordSchema()); theEvent.Put("OrderId", orderId); theEvent.Put("ProductId", productId); theEvent.Put("Price", price); theEvent.Put("Quantity", quantity); theEvent.Put("DeletedFlag", deletedFlag); env.EventService.SendEventAvro(theEvent, "OrderEvent"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { var @object = new JObject(); @object.Add("OrderId", orderId); @object.Add("ProductId", productId); @object.Add("Price", price); @object.Add("Quantity", quantity); @object.Add("DeletedFlag", deletedFlag); env.EventService.SendEventJson(@object.ToString(), "OrderEvent"); } else { Assert.Fail(); } }
public void Run(RegressionEnvironment env) { var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSchemaOne>() + " @name('schema') create schema SchemaOne(col1 int, col2 int);\n"; epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSchemaWindow>() + " @name('create') create window SchemaWindow#lastevent as (s1 SchemaOne);\n"; epl += "insert into SchemaWindow (s1) select sone from SchemaOne as sone;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("create"); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("schema").EventType.UnderlyingType)); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("create").EventType.UnderlyingType)); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {10, 11}, "SchemaOne"); } else if (eventRepresentationEnum.IsMapEvent()) { IDictionary<string, object> theEvent = new Dictionary<string, object>(); theEvent.Put("col1", 10); theEvent.Put("col2", 11); env.SendEventMap(theEvent, "SchemaOne"); } else if (eventRepresentationEnum.IsAvroEvent()) { var theEvent = new GenericRecord( SupportAvroUtil .GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("SchemaOne")) .AsRecordSchema()); theEvent.Put("col1", 10); theEvent.Put("col2", 11); env.EventService.SendEventAvro(theEvent, "SchemaOne"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.EventService.SendEventJson("{\"col1\": 10, \"col2\": 11}", "SchemaOne"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps( env.Listener("create").AssertOneGetNewAndReset(), new[] {"s1.col1", "s1.col2"}, new object[] {10, 11}); env.UndeployAll(); }
private static void RunAssertPopulateFromNamedWindow( RegressionEnvironment env, EventRepresentationChoice type) { var path = new RegressionPath(); var schemaEPL = type.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedNode>() + "create schema Node(nid string)"; env.CompileDeployWBusPublicType(schemaEPL, path); env.CompileDeploy("create window NodeWindow#unique(nid) as Node", path); env.CompileDeploy("insert into NodeWindow select * from Node", path); env.CompileDeploy( type.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedNodePlus>() + "create schema NodePlus(npid string, node Node)", path); env.CompileDeploy("@Name('s0') insert into NodePlus select 'E1' as npid, n1 as node from NodeWindow n1", path).AddListener("s0"); if (type.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {"n1"}, "Node"); } else if (type.IsMapEvent()) { env.SendEventMap(Collections.SingletonDataMap("nid", "n1"), "Node"); } else if (type.IsAvroEvent()) { var genericRecord = new GenericRecord(SchemaBuilder.Record("name", RequiredString("nid"))); genericRecord.Put("nid", "n1"); env.SendEventAvro(genericRecord, "Node"); } else if (type.IsJsonEvent() || type.IsJsonProvidedClassEvent()) { var @object = new JObject(); @object.Add("nid", "n1"); env.SendEventJson(@object.ToString(), "Node"); } else { Assert.Fail(); } var @event = env.Listener("s0").AssertOneGetNewAndReset(); Assert.AreEqual("E1", @event.Get("npid")); Assert.AreEqual("n1", @event.Get("node.nid")); var fragment = (EventBean) @event.GetFragment("node"); Assert.AreEqual("Node", fragment.EventType.Name); env.UndeployAll(); }
private static void MakeSendScoreEvent( RegressionEnvironment env, string typeName, EventRepresentationChoice eventRepresentationEnum, string userId, string keyword, string productId, long score) { if (eventRepresentationEnum.IsMapEvent()) { IDictionary<string, object> theEvent = new LinkedHashMap<string, object>(); theEvent.Put("UserId", userId); theEvent.Put("Keyword", keyword); theEvent.Put("ProductId", productId); theEvent.Put("Score", score); env.SendEventMap(theEvent, typeName); } else if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {userId, keyword, productId, score}, typeName); } else if (eventRepresentationEnum.IsAvroEvent()) { var record = new GenericRecord( SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(typeName)) .AsRecordSchema()); record.Put("UserId", userId); record.Put("Keyword", keyword); record.Put("ProductId", productId); record.Put("Score", score); env.SendEventAvro(record, typeName); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { var jobject = new JObject(); jobject.Add("UserId", userId); jobject.Add("Keyword", keyword); jobject.Add("ProductId", productId); jobject.Add("Score", score); env.SendEventJson(jobject.ToString(), typeName); } else { Assert.Fail(); } }
private static void RunAssertionCreateStream( RegressionEnvironment env, EventRepresentationChoice representation) { var epl = representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyEvent>() + " create schema MyEvent(myId int);\n" + representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedCompositeEvent>() + " create schema CompositeEvent(c1 MyEvent, c2 MyEvent, rule string);\n" + "insert into MyStream select c, 'additionalValue' as value from MyEvent c;\n" + "insert into CompositeEvent select e1.c as c1, e2.c as c2, '4' as rule " + " from pattern [e1=MyStream -> e2=MyStream];\n" + representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedCompositeEvent>() + " @Name('Target') select * from CompositeEvent;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("Target"); if (representation.IsObjectArrayEvent()) { env.SendEventObjectArray(MakeEvent(10).Values.ToArray(), "MyEvent"); env.SendEventObjectArray(MakeEvent(11).Values.ToArray(), "MyEvent"); } else if (representation.IsMapEvent()) { env.SendEventMap(MakeEvent(10), "MyEvent"); env.SendEventMap(MakeEvent(11), "MyEvent"); } else if (representation.IsAvroEvent()) { env.SendEventAvro(MakeEventAvro(10), "MyEvent"); env.SendEventAvro(MakeEventAvro(11), "MyEvent"); } else if (representation.IsJsonEvent() || representation.IsJsonProvidedClassEvent()) { env.SendEventJson("{\"myId\": 10}", "MyEvent"); env.SendEventJson("{\"myId\": 11}", "MyEvent"); } else { Assert.Fail(); } var theEvent = env.Listener("Target").AssertOneGetNewAndReset(); Assert.AreEqual(10, theEvent.Get("c1.myId")); Assert.AreEqual(11, theEvent.Get("c2.myId")); Assert.AreEqual("4", theEvent.Get("rule")); env.UndeployAll(); }
private void TryAssertionCreateSchemaModelAfter( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedEventTypeOne>() + " create schema EventTypeOne (hsi int);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedEventTypeTwo>() + " create schema EventTypeTwo (event EventTypeOne);\n" + "@Name('create') create window NamedWindow#unique(event.hsi) as EventTypeTwo;\n" + "on EventTypeOne as ev insert into NamedWindow select ev as event;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {10}, "EventTypeOne"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(Collections.SingletonDataMap("hsi", 10), "EventTypeOne"); } else if (eventRepresentationEnum.IsAvroEvent()) { var theEvent = new GenericRecord( SupportAvroUtil .GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("EventTypeOne")) .AsRecordSchema()); theEvent.Put("hsi", 10); env.EventService.SendEventAvro(theEvent, "EventTypeOne"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.EventService.SendEventJson("{\"hsi\": 10}", "EventTypeOne"); } else { Assert.Fail(); } var result = env.Statement("create").First(); var getter = result.EventType.GetGetter("event.hsi"); Assert.AreEqual(10, getter.Get(result)); env.UndeployAll(); }
private static void RunStreamInsertAssertion( RegressionEnvironment env, RegressionPath path, EventRepresentationChoice rep, string epl, string fields, object[] expected) { env.CompileDeploy("@Name('s0') " + epl, path).AddListener("s0"); if (rep.IsMapEvent()) { env.SendEventMap(MakeMap(123, "abc"), "Src"); } else if (rep.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {123, "abc"}, "Src"); } else if (rep.IsAvroEvent()) { var eventType = env.Runtime.EventTypeService.GetEventType(env.DeploymentId("schema"), "Src"); var @event = new GenericRecord(SupportAvroUtil.GetAvroSchema(eventType).AsRecordSchema()); @event.Put("myint", 123); @event.Put("mystr", "abc"); env.SendEventAvro(@event, "Src"); } else if (rep.IsJsonEvent() || rep.IsJsonProvidedClassEvent()) { JObject @object = new JObject(); @object.Add("myint", 123); @object.Add("mystr", "abc"); env.SendEventJson(@object.ToString(), "Src"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields.SplitCsv(), expected); env.UndeployModuleContaining("s0"); }
private static void RunAssertionEventBeanAnnotation( RegressionEnvironment env, EventRepresentationChoice rep) { var path = new RegressionPath(); env.CompileDeployWBusPublicType( rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyEvent>() + "@Name('schema') create schema MyEvent(col1 string)", path); var eplInsert = "@Name('insert') insert into DStream select " + "last(*) @eventbean as c0, " + "window(*) @eventbean as c1, " + "prevwindow(s0) @eventbean as c2 " + "from MyEvent#length(2) as s0"; env.CompileDeploy(eplInsert, path).AddListener("insert"); foreach (var prop in "c0,c1,c2".SplitCsv()) { AssertFragment(prop, env.Statement("insert").EventType, "MyEvent", prop.Equals("c1") || prop.Equals("c2")); } // test consuming statement var fields = "f0,f1,f2,f3,f4,f5".SplitCsv(); env.CompileDeploy( "@Name('s0') select " + "c0 as f0, " + "c0.col1 as f1, " + "c1 as f2, " + "c1.lastOf().col1 as f3, " + "c1 as f4, " + "c1.lastOf().col1 as f5 " + "from DStream", path) .AddListener("s0"); env.CompileDeploy("@Name('s1') select * from MyEvent", path).AddListener("s1"); var eventOne = SendEvent(env, rep, "E1"); if (rep.IsJsonEvent() || rep.IsJsonProvidedClassEvent()) { eventOne = env.Listener("s1").AssertOneGetNewAndReset().Underlying; } var underlying = env.Listener("insert").AssertOneGetNewAndReset().Underlying.AsStringDictionary(); Assert.IsTrue(underlying.Get("c0") is EventBean); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new[] {eventOne, "E1", new[] {eventOne}, "E1", new[] {eventOne}, "E1"}); var eventTwo = SendEvent(env, rep, "E2"); if (rep.IsJsonEvent() || rep.IsJsonProvidedClassEvent()) { eventTwo = env.Listener("s1").AssertOneGetNewAndReset().Underlying; } EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new[] {eventTwo, "E2", new[] {eventOne, eventTwo}, "E2", new[] {eventOne, eventTwo}, "E2"}); // test SODA env.EplToModelCompileDeploy(eplInsert, path); // test invalid TryInvalidCompile( env, path, "@Name('s0') select last(*) @xxx from MyEvent", "Failed to recognize select-expression annotation 'xxx', expected 'eventbean' in text 'last(*) @xxx'"); env.UndeployAll(); }
private static void TryAssertionNamedWindow( RegressionEnvironment env, EventRepresentationChoice rep) { RegressionPath path = new RegressionPath(); string schema = rep.GetAnnotationText() + "@Name('schema') create schema A as (myint int, mystr string);\n" + rep.GetAnnotationText() + "create schema C as (addprop int) inherits A;\n"; env.CompileDeployWBusPublicType(schema, path); env.CompileDeploy("create window MyWindow#time(5 days) as C", path); env.CompileDeploy("@Name('s0') select * from MyWindow", path).AddListener("s0"); // select underlying env.CompileDeploy("@Name('insert') insert into MyWindow select mya.* from A as mya", path); if (rep.IsMapEvent()) { env.SendEventMap(MakeMap(123, "abc"), "A"); } else if (rep.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {123, "abc"}, "A"); } else if (rep.IsAvroEvent()) { env.SendEventAvro(MakeAvro(env, 123, "abc"), "A"); } else if (rep.IsJsonEvent() || rep.IsJsonProvidedClassEvent()) { var @object = new JObject(); @object.Add("myint", 123); @object.Add("mystr", "abc"); env.SendEventJson(@object.ToString(), "A"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), "myint,mystr,addprop".SplitCsv(), new object[] {123, "abc", null}); env.UndeployModuleContaining("insert"); // select underlying plus property env.CompileDeploy("insert into MyWindow select mya.*, 1 as addprop from A as mya", path); if (rep.IsMapEvent()) { env.SendEventMap(MakeMap(456, "def"), "A"); } else if (rep.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {456, "def"}, "A"); } else if (rep.IsAvroEvent()) { env.SendEventAvro(MakeAvro(env, 456, "def"), "A"); } else if (rep.IsJsonEvent() || rep.IsJsonProvidedClassEvent()) { var @object = new JObject(); @object.Add("myint", 456); @object.Add("mystr", "def"); env.SendEventJson(@object.ToString(), "A"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), "myint,mystr,addprop".SplitCsv(), new object[] {456, "def", 1}); env.UndeployAll(); }
private static void TryAssertionSingleRowSplitAndType( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var path = new RegressionPath(); var types = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonSentence>() + " create schema MySentenceEvent(sentence String);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonWord>() + " create schema WordEvent(word String);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonCharacter>() + " create schema CharacterEvent(character String);\n"; env.CompileDeployWBusPublicType(types, path); string stmtText; var fields = new[] {"word"}; // test single-row method stmtText = "@Name('s0') select * from MySentenceEvent[splitSentence" + "_" + eventRepresentationEnum.GetName() + "(sentence)@type(WordEvent)]"; env.CompileDeploy(stmtText, path).AddListener("s0"); Assert.AreEqual("WordEvent", env.Statement("s0").EventType.Name); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("s0").EventType.UnderlyingType)); SendMySentenceEvent(env, eventRepresentationEnum, "I am testing this code"); EPAssertionUtil.AssertPropsPerRow( env.Listener("s0").GetAndResetLastNewData(), fields, new[] { new object[] {"I"}, new object[] {"am"}, new object[] {"testing"}, new object[] {"this"}, new object[] {"code"} }); SendMySentenceEvent(env, eventRepresentationEnum, "the second event"); EPAssertionUtil.AssertPropsPerRow( env.Listener("s0").GetAndResetLastNewData(), fields, new[] { new object[] {"the"}, new object[] {"second"}, new object[] {"event"} }); env.UndeployModuleContaining("s0"); // test SODA env.EplToModelCompileDeploy(stmtText, path).AddListener("s0"); SendMySentenceEvent(env, eventRepresentationEnum, "the third event"); EPAssertionUtil.AssertPropsPerRow( env.Listener("s0").GetAndResetLastNewData(), fields, new[] { new object[] {"the"}, new object[] {"third"}, new object[] {"event"} }); env.UndeployModuleContaining("s0"); // test script if (eventRepresentationEnum.IsMapEvent()) { stmtText = "@Name('s0') expression System.Collections.IList js:SplitSentenceJS(sentence) [" + " var listType = host.resolveType('System.Collections.Generic.List<object>');" + " var words = host.newObj(listType);" + " words.Add(Collections.SingletonDataMap('word', 'wordOne'));" + " words.Add(Collections.SingletonDataMap('word', 'wordTwo'));" + " return words;" + "]" + "select * from MySentenceEvent[SplitSentenceJS(sentence)@type(WordEvent)]"; env.CompileDeploy(stmtText, path).AddListener("s0"); Assert.AreEqual("WordEvent", env.Statement("s0").EventType.Name); env.SendEventMap(Collections.EmptyDataMap, "MySentenceEvent"); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.Listener("s0").GetAndResetLastNewData(), fields, new[] { new object[] {"wordOne"}, new object[] {"wordTwo"} }); env.UndeployModuleContaining("s0"); } // test multiple splitters stmtText = "@Name('s0') select * from " + "MySentenceEvent" + "[splitSentence_" + eventRepresentationEnum.GetName() + "(sentence)" + "@type(WordEvent)]" + "[splitWord_" + eventRepresentationEnum.GetName() + "(word)" + "@type(CharacterEvent)]"; env.CompileDeploy(stmtText, path).AddListener("s0"); Assert.AreEqual("CharacterEvent", env.Statement("s0").EventType.Name); SendMySentenceEvent(env, eventRepresentationEnum, "I am"); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.Listener("s0").GetAndResetLastNewData(), new[] {"character"}, new[] { new object[] {"I"}, new object[] {"a"}, new object[] {"m"} }); env.UndeployModuleContaining("s0"); // test wildcard parameter stmtText = "@Name('s0') select * from MySentenceEvent[splitSentenceBean_" + eventRepresentationEnum.GetName() + "(*)@type(WordEvent)]"; env.CompileDeploy(stmtText, path).AddListener("s0"); Assert.AreEqual("WordEvent", env.Statement("s0").EventType.Name); SendMySentenceEvent(env, eventRepresentationEnum, "another test sentence"); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.Listener("s0").GetAndResetLastNewData(), fields, new[] { new object[] {"another"}, new object[] {"test"}, new object[] {"sentence"} }); env.UndeployModuleContaining("s0"); // test property returning untyped collection if (eventRepresentationEnum.IsObjectArrayEvent()) { stmtText = eventRepresentationEnum.GetAnnotationText() + " @Name('s0') select * from SupportObjectArrayEvent[SomeObjectArray@type(WordEvent)]"; env.CompileDeploy(stmtText, path).AddListener("s0"); Assert.AreEqual("WordEvent", env.Statement("s0").EventType.Name); object[][] rows = { new object[] {"this"}, new object[] {"is"}, new object[] {"collection"} }; env.SendEventBean(new SupportObjectArrayEvent(rows)); EPAssertionUtil.AssertPropsPerRow( env.Listener("s0").GetAndResetLastNewData(), fields, new[] { new object[] {"this"}, new object[] {"is"}, new object[] {"collection"} }); env.UndeployAll(); } else if (eventRepresentationEnum.IsMapEvent()) { stmtText = eventRepresentationEnum.GetAnnotationText() + " @Name('s0') select * from SupportCollectionEvent[SomeCollection@type(WordEvent)]"; env.CompileDeploy(stmtText, path).AddListener("s0"); Assert.AreEqual("WordEvent", env.Statement("s0").EventType.Name); var coll = new List<IDictionary<string, object>>(); coll.Add(Collections.SingletonDataMap("word", "this")); coll.Add(Collections.SingletonDataMap("word", "is")); coll.Add(Collections.SingletonDataMap("word", "collection")); env.SendEventBean(new SupportCollectionEvent(coll.Unwrap<object>())); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.Listener("s0").GetAndResetLastNewData(), fields, new[] { new object[] {"this"}, new object[] {"is"}, new object[] {"collection"} }); env.UndeployAll(); } else if (eventRepresentationEnum.IsAvroEvent()) { stmtText = "@Name('s0') " + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonWord>() + " select * from SupportAvroArrayEvent[SomeAvroArray@type(WordEvent)]"; env.CompileDeploy(stmtText, path).AddListener("s0"); Assert.AreEqual("WordEvent", env.Statement("s0").EventType.Name); var rows = new GenericRecord[3]; var words = new[] {"this", "is", "avro"}; for (var i = 0; i < words.Length; i++) { rows[i] = new GenericRecord( ((AvroEventType) env.Statement("s0").EventType).SchemaAvro.AsRecordSchema()); rows[i].Put("word", words[i]); } env.SendEventBean(new SupportAvroArrayEvent(rows)); EPAssertionUtil.AssertPropsPerRow( env.Listener("s0").GetAndResetLastNewData(), fields, new[] { new object[] {"this"}, new object[] {"is"}, new object[] {"avro"} }); env.UndeployAll(); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { stmtText = "@Name('s0') " + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonWord>() + " select * from SupportJsonArrayEvent[SomeJsonArray@type(WordEvent)]"; env.CompileDeploy(stmtText, path).AddListener("s0"); Assert.AreEqual("WordEvent", env.Statement("s0").EventType.Name); var rows = new string[3]; var words = "this,is,avro".SplitCsv(); for (var i = 0; i < words.Length; i++) { rows[i] = "{ \"word\": \"" + words[i] + "\"}"; } env.SendEventBean(new SupportJsonArrayEvent(rows)); EPAssertionUtil.AssertPropsPerRow( env.Listener("s0").GetAndResetLastNewData(), fields, new object[][] { new[] {"this"}, new[] {"is"}, new[] {"avro"} }); env.UndeployAll(); } else { throw new ArgumentException("Unrecognized enum " + eventRepresentationEnum); } // invalid: event type not found TryInvalidCompile( env, path, "select * from MySentenceEvent[splitSentence_" + eventRepresentationEnum.GetName() + "(sentence)@type(XYZ)]", "Event type by name 'XYZ' could not be found"); // invalid lib-function annotation TryInvalidCompile( env, path, "select * from MySentenceEvent[splitSentence_" + eventRepresentationEnum.GetName() + "(sentence)@dummy(WordEvent)]", "Invalid annotation for property selection, expected 'type' but found 'dummy' in text '@dummy(WordEvent)'"); // invalid type assignment to event type if (eventRepresentationEnum.IsObjectArrayEvent()) { TryInvalidCompile( env, path, "select * from MySentenceEvent[invalidSentence(sentence)@type(WordEvent)]", "Event type 'WordEvent' underlying type System.Object[] cannot be assigned a value of type"); } else if (eventRepresentationEnum.IsMapEvent()) { TryInvalidCompile( env, path, "select * from MySentenceEvent[invalidSentence(sentence)@type(WordEvent)]", "Event type 'WordEvent' underlying type System.Collections.Generic.IDictionary<System.String, System.Object> cannot be assigned a value of type"); } else if (eventRepresentationEnum.IsAvroEvent()) { TryInvalidCompile( env, path, "select * from MySentenceEvent[invalidSentence(sentence)@type(WordEvent)]", "Event type 'WordEvent' underlying type " + TypeHelper.AVRO_GENERIC_RECORD_CLASSNAME + " cannot be assigned a value of type"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { TryInvalidCompile( env, path, "select * from MySentenceEvent[invalidSentence(sentence)@type(WordEvent)]", "Event type 'WordEvent' requires string-type array and cannot be assigned from value of type " + typeof(SupportBean[]).CleanName()); } else { Assert.Fail(); } // invalid subquery TryInvalidCompile( env, path, "select * from MySentenceEvent[splitSentence((select * from SupportBean#keepall))@type(WordEvent)]", "Invalid Contained-event expression 'splitSentence(subselect_0)': Aggregation, sub-select, previous or prior functions are not supported in this context [select * from MySentenceEvent[splitSentence((select * from SupportBean#keepall))@type(WordEvent)]]"); env.UndeployAll(); }
private static void TryAssertionFragment( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided <MyLocalJsonProvidedInnerSchema>() + " create schema InnerSchema as (key string);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided <MyLocalJsonProvidedMySchema>() + " create schema MySchema as (inside InnerSchema, insidearr InnerSchema[]);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided <MyLocalJsonProvidedOut>() + " @name('s0') select typeof(s0.inside) as t0, typeof(s0.insidearr) as t1 from MySchema as s0;\n"; var fields = new[] { "t0", "t1" }; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("s0"); var deploymentId = env.DeploymentId("s0"); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[2], "MySchema"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(new Dictionary <string, object>(), "MySchema"); } else if (eventRepresentationEnum.IsAvroEvent()) { var schema = SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventType(deploymentId, "MySchema")).AsRecordSchema(); env.SendEventAvro(new GenericRecord(schema), "MySchema"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.SendEventJson("{}", "MySchema"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, null, null); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] { new object[2], null }, "MySchema"); } else if (eventRepresentationEnum.IsMapEvent()) { IDictionary <string, object> theEvent = new Dictionary <string, object>(); theEvent.Put("inside", new Dictionary <string, object>()); env.SendEventMap(theEvent, "MySchema"); } else if (eventRepresentationEnum.IsAvroEvent()) { var mySchema = SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventType(deploymentId, "MySchema")).AsRecordSchema(); var innerSchema = SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventType(deploymentId, "InnerSchema")).AsRecordSchema(); var @event = new GenericRecord(mySchema); @event.Put("inside", new GenericRecord(innerSchema)); env.SendEventAvro(@event, "MySchema"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { var theEvent = new JObject(new JProperty("inside", new JObject())); env.SendEventJson(theEvent.ToString(), "MySchema"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, "InnerSchema", null); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] { null, new object[2][] }, "MySchema"); } else if (eventRepresentationEnum.IsMapEvent()) { IDictionary <string, object> theEvent = new Dictionary <string, object>(); theEvent.Put("insidearr", new IDictionary <string, object> [0]); env.SendEventMap(theEvent, "MySchema"); } else if (eventRepresentationEnum.IsAvroEvent()) { var mySchema = SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventType(deploymentId, "MySchema")).AsRecordSchema(); var @event = new GenericRecord(mySchema); @event.Put("insidearr", EmptyList <object> .Instance); env.SendEventAvro(@event, "MySchema"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { var theEvent = new JObject(new JProperty("insidearr", new JArray(new JObject()))); env.SendEventJson(theEvent.ToString(), "MySchema"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, null, "InnerSchema[]"); env.UndeployAll(); }
private static void TryAssertionVariantStream( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var eplSchemas = eventRepresentationEnum.GetAnnotationTextWJsonProvided <MyLocalJsonProvidedWKey>() + " create schema EventOne as (key string);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided <MyLocalJsonProvidedWKey>() + " create schema EventTwo as (key string);\n" + " create schema S0 as " + typeof(SupportBean_S0).FullName + ";\n" + " create variant schema VarSchema as *;\n"; var path = new RegressionPath(); env.CompileDeployWBusPublicType(eplSchemas, path); env.CompileDeploy("insert into VarSchema select * from EventOne", path); env.CompileDeploy("insert into VarSchema select * from EventTwo", path); env.CompileDeploy("insert into VarSchema select * from S0", path); env.CompileDeploy("insert into VarSchema select * from SupportBean", path); var stmtText = "@Name('s0') select typeof(A) as t0 from VarSchema as A"; env.CompileDeploy(stmtText, path).AddListener("s0"); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] { "value" }, "EventOne"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(Collections.SingletonDataMap("key", "value"), "EventOne"); } else if (eventRepresentationEnum.IsAvroEvent()) { var record = new GenericRecord(SchemaBuilder.Record("EventOne", RequiredString("key"))); record.Put("key", "value"); env.SendEventAvro(record, "EventOne"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.SendEventJson(new JObject(new JProperty("key", "value")).ToString(), "EventOne"); } else { Assert.Fail(); } Assert.AreEqual("EventOne", env.Listener("s0").AssertOneGetNewAndReset().Get("t0")); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] { "value" }, "EventTwo"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(Collections.SingletonDataMap("key", "value"), "EventTwo"); } else if (eventRepresentationEnum.IsAvroEvent()) { var record = new GenericRecord(SchemaBuilder.Record("EventTwo", RequiredString("key"))); record.Put("key", "value"); env.SendEventAvro(record, "EventTwo"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.SendEventJson(new JObject(new JProperty("key", "value")).ToString(), "EventTwo"); } else { Assert.Fail(); } Assert.AreEqual("EventTwo", env.Listener("s0").AssertOneGetNewAndReset().Get("t0")); env.SendEventBean(new SupportBean_S0(1), "S0"); Assert.AreEqual("S0", env.Listener("s0").AssertOneGetNewAndReset().Get("t0")); env.SendEventBean(new SupportBean()); Assert.AreEqual("SupportBean", env.Listener("s0").AssertOneGetNewAndReset().Get("t0")); env.UndeployModuleContaining("s0"); env.CompileDeploy( "@Name('s0') select * from VarSchema match_recognize(\n" + " measures A as a, B as b\n" + " pattern (A B)\n" + " define A as typeof(A) = \"EventOne\",\n" + " B as typeof(B) = \"EventTwo\"\n" + " )", path) .AddListener("s0"); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] { "value" }, "EventOne"); env.SendEventObjectArray(new object[] { "value" }, "EventTwo"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(Collections.SingletonDataMap("key", "value"), "EventOne"); env.SendEventMap(Collections.SingletonDataMap("key", "value"), "EventTwo"); } else if (eventRepresentationEnum.IsAvroEvent()) { var schema = SchemaBuilder.Record("EventTwo", RequiredString("key")); var eventOne = new GenericRecord(schema); eventOne.Put("key", "value"); var eventTwo = new GenericRecord(schema); eventTwo.Put("key", "value"); env.SendEventAvro(eventOne, "EventOne"); env.SendEventAvro(eventTwo, "EventTwo"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.SendEventJson(new JObject(new JProperty("key", "value")).ToString(), "EventOne"); env.SendEventJson(new JObject(new JProperty("key", "value")).ToString(), "EventTwo"); } else { Assert.Fail(); } Assert.IsTrue(env.Listener("s0").GetAndClearIsInvoked()); env.UndeployAll(); }
private static void TryAssertionWildcard( RegressionEnvironment env, bool bean, EventRepresentationChoice rep) { var path = new RegressionPath(); EPCompiled schemaCompiled; if (bean) { schemaCompiled = env.Compile( "create schema MySchema as " + typeof(MyP0P1Event).Name, options => { options.BusModifierEventType = ctx => EventTypeBusModifier.BUS; options.AccessModifierEventType = ctx => NameAccessModifier.PUBLIC; }); } else { schemaCompiled = env.Compile( rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMySchema>() + "create schema MySchema (P0 string, P1 string)", options => { options.SetBusModifierEventType(ctx => EventTypeBusModifier.BUS); options.SetAccessModifierEventType(ctx => NameAccessModifier.PUBLIC); }); } path.Add(schemaCompiled); env.Deploy(schemaCompiled); env.CompileDeploy("@Name('create') create table TheTable (P0 string, P1 string)", path); env.CompileDeploy("insert into TheTable select * from MySchema", path); if (bean) { env.SendEventBean(new MyP0P1Event("a", "b"), "MySchema"); } else if (rep.IsMapEvent()) { IDictionary<string, object> map = new Dictionary<string, object>(); map.Put("P0", "a"); map.Put("P1", "b"); env.SendEventMap(map, "MySchema"); } else if (rep.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {"a", "b"}, "MySchema"); } else if (rep.IsAvroEvent()) { var theEvent = new GenericRecord( SupportAvroUtil.GetAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured("MySchema")) .AsRecordSchema()); theEvent.Put("P0", "a"); theEvent.Put("P1", "b"); env.EventService.SendEventAvro(theEvent, "MySchema"); } else if (rep.IsJsonEvent() || rep.IsJsonProvidedClassEvent()) { env.EventService.SendEventJson( new JObject( new JProperty("P0", "a"), new JProperty("P1", "b")).ToString(), "MySchema"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps( env.GetEnumerator("create").Advance(), new[] {"P0", "P1"}, new object[] {"a", "b"}); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { string epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedStartValueEvent>() + " create schema StartValueEvent as (dummy string);\n"; epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTestForwardEvent>() + " create schema TestForwardEvent as (prop1 string);\n"; epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedTestInputEvent>() + " create schema TestInputEvent as (dummy string);\n"; epl += "insert into TestForwardEvent select'V1' as prop1 from TestInputEvent;\n"; epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedNamedWin>() + " create window NamedWin#unique(prop1) (prop1 string, prop2 string);\n"; epl += "insert into NamedWin select 'V1' as prop1, 'O1' as prop2 from StartValueEvent;\n"; epl += "on TestForwardEvent update NamedWin as work set prop2 = 'U1' where work.prop1 = 'V1';\n"; epl += "@Name('select') select irstream prop1, prop2 from NamedWin;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("select"); var fields = new[] {"prop1", "prop2"}; if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {"dummyValue"}, "StartValueEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(new Dictionary<string, object>(), "StartValueEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { env.EventService.SendEventAvro( new GenericRecord( SchemaBuilder.Record("soemthing")), "StartValueEvent"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.EventService.SendEventJson("{}", "StartValueEvent"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps( env.Listener("select").AssertOneGetNewAndReset(), fields, new object[] {"V1", "O1"}); if (eventRepresentationEnum.IsObjectArrayEvent()) { env.SendEventObjectArray(new object[] {"dummyValue"}, "TestInputEvent"); } else if (eventRepresentationEnum.IsMapEvent()) { env.SendEventMap(new Dictionary<string, object>(), "TestInputEvent"); } else if (eventRepresentationEnum.IsAvroEvent()) { env.EventService.SendEventAvro( new GenericRecord( SchemaBuilder.Record("soemthing")), "TestInputEvent"); } else if (eventRepresentationEnum.IsJsonEvent() || eventRepresentationEnum.IsJsonProvidedClassEvent()) { env.EventService.SendEventJson("{}", "TestInputEvent"); } else { Assert.Fail(); } EPAssertionUtil.AssertProps( env.Listener("select").LastOldData[0], fields, new object[] {"V1", "O1"}); EPAssertionUtil.AssertProps( env.Listener("select").GetAndResetLastNewData()[0], fields, new object[] {"V1", "U1"}); env.UndeployAll(); }