public void Run(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeploy(representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedNested>() + "create schema Nested(p0 string, p1 int)", path); env.CompileDeploy(representation.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedOuterType>() + "create schema OuterType(n0 Nested)", path); var fields = new[] {"n0.p0", "n0.p1"}; env.CompileDeploy( "@Name('out') " + "expression computeNested {\n" + " sb -> case\n" + " when IntPrimitive = 1 \n" + " then new { p0 = 'a', p1 = 1}\n" + " else new { p0 = 'b', p1 = 2 }\n" + " end\n" + "}\n" + "insert into OuterType select computeNested(sb) as n0 from SupportBean as sb", path) .AddListener("out"); env.SendEventBean(new SupportBean("E1", 2)); EPAssertionUtil.AssertProps( env.Listener("out").AssertOneGetNewAndReset(), fields, new object[] {"b", 2}); env.SendEventBean(new SupportBean("E2", 1)); EPAssertionUtil.AssertProps( env.Listener("out").AssertOneGetNewAndReset(), fields, new object[] {"a", 1}); env.UndeployAll(); }
private void TryAssertionInsertWhereOMStaggered( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var path = new RegressionPath(); var stmtTextCreateOne = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyWindowIWOM>() + " @Name('window') create window MyWindowIWOM#keepall as select a, b from MyMapAB"; env.CompileDeploy(stmtTextCreateOne, path); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("window").EventType.UnderlyingType)); env.AddListener("window"); // create insert into var stmtTextInsertOne = "insert into MyWindowIWOM select a, b from MyMapAB"; env.CompileDeploy(stmtTextInsertOne, path); // populate some data env.SendEventMap(BuildMap(new[] {new object[] {"a", "E1"}, new object[] {"b", 2}}), "MyMapAB"); env.SendEventMap(BuildMap(new[] {new object[] {"a", "E2"}, new object[] {"b", 10}}), "MyMapAB"); env.SendEventMap(BuildMap(new[] {new object[] {"a", "E3"}, new object[] {"b", 10}}), "MyMapAB"); // create window with keep-all using OM var model = new EPStatementObjectModel(); eventRepresentationEnum.AddAnnotationForNonMap(model); Expression where = Expressions.Eq("b", 10); model.CreateWindow = CreateWindowClause.Create("MyWindowIWOMTwo", View.Create("keepall")) .WithInsert(true) .WithInsertWhereClause(where) .WithAsEventTypeName("MyWindowIWOM"); model.SelectClause = SelectClause.CreateWildcard(); var text = eventRepresentationEnum.GetAnnotationTextForNonMap() + " create window MyWindowIWOMTwo#keepall as select * from MyWindowIWOM insert where b=10"; Assert.AreEqual(text.Trim(), model.ToEPL()); var modelTwo = env.EplToModel(text); Assert.AreEqual(text.Trim(), modelTwo.ToEPL()); modelTwo.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("windowTwo")); env.CompileDeploy(modelTwo, path).AddListener("windowTwo"); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("windowTwo"), new[] {"a", "b"}, new[] {new object[] {"E2", 10}, new object[] {"E3", 10}}); // test select individual fields and from an insert-from named window env.CompileDeploy( eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyWindowIWOMThree>() + " @Name('windowThree') create window MyWindowIWOMThree#keepall as select a from MyWindowIWOMTwo insert where a = 'E2'", path); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("windowThree"), new[] {"a"}, new[] {new object[] {"E2"}}); 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 TryJoinAssertion( RegressionEnvironment env, String epl, EventRepresentationChoice rep, String columnNames, AtomicLong milestone, RegressionPath path, Type jsonClass) { env.CompileDeploy("@Name('s0')" + rep.GetAnnotationTextWJsonProvided(jsonClass) + epl, path) .AddListener("s0") .MilestoneInc(milestone); var s0Name = "S0_" + rep.GetName(); var s1Name = "S1_" + rep.GetName(); SendRepEvent(env, rep, s0Name, "a", 1); Assert.IsFalse(env.Listener("s0").IsInvoked); SendRepEvent(env, rep, s1Name, "a", 2); var output = env.Listener("s0").AssertOneGetNewAndReset(); EPAssertionUtil.AssertProps( output, columnNames.SplitCsv(), new object[] {"a", "a", 1, 2}); Assert.IsTrue(rep.MatchesClass(output.Underlying.GetType())); SendRepEvent(env, rep, s1Name, "b", 3); SendRepEvent(env, rep, s0Name, "c", 4); Assert.IsFalse(env.Listener("s0").IsInvoked); env.UndeployModuleContaining("s0"); }
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 TryAssertionInnerJoinLateStart( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var schemaEPL = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedProduct>() + "@Name('schema') create schema Product (product string, size int);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedPortfolio>() + " create schema Portfolio (portfolio string, product string);\n"; var path = new RegressionPath(); env.CompileDeployWBusPublicType(schemaEPL, path); env.CompileDeploy("@Name('window') create window ProductWin#keepall as Product", path); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("schema").EventType.UnderlyingType)); Assert.IsTrue(eventRepresentationEnum.MatchesClass(env.Statement("window").EventType.UnderlyingType)); env.CompileDeploy("insert into ProductWin select * from Product", path); env.CompileDeploy("create window PortfolioWin#keepall as Portfolio", path); env.CompileDeploy("insert into PortfolioWin select * from Portfolio", path); SendProduct(env, eventRepresentationEnum, "productA", 1); SendProduct(env, eventRepresentationEnum, "productB", 2); sendPortfolio(env, eventRepresentationEnum, "Portfolio", "productA"); var stmtText = "@Name(\"Query2\") select portfolio, ProductWin.product, size " + "from PortfolioWin unidirectional inner join ProductWin on PortfolioWin.product=ProductWin.product"; env.CompileDeploy(stmtText, path).AddListener("Query2"); sendPortfolio(env, eventRepresentationEnum, "Portfolio", "productB"); EPAssertionUtil.AssertProps( env.Listener("Query2").AssertOneGetNewAndReset(), new[] {"portfolio", "ProductWin.product", "size"}, new object[] {"Portfolio", "productB", 2}); sendPortfolio(env, eventRepresentationEnum, "Portfolio", "productC"); env.Listener("Query2").Reset(); SendProduct(env, eventRepresentationEnum, "productC", 3); sendPortfolio(env, eventRepresentationEnum, "Portfolio", "productC"); EPAssertionUtil.AssertProps( env.Listener("Query2").AssertOneGetNewAndReset(), new[] {"portfolio", "ProductWin.product", "size"}, new object[] {"Portfolio", "productC", 3}); env.UndeployAll(); }
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 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 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 RunAssertionCreateSchemaWTypes<T>( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum, string typeOfDatetimeProp, object startA, object endA, object startB, object endB) { var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<T>() + " create schema TypeA as (startts " + typeOfDatetimeProp + ", endts " + typeOfDatetimeProp + ") starttimestamp startts endtimestamp endts;\n"; epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<T>() + " create schema TypeB as (startts " + typeOfDatetimeProp + ", endts " + typeOfDatetimeProp + ") starttimestamp startts endtimestamp endts;\n"; epl += "@Name('s0') select a.includes(b) as val0 from TypeA#lastevent as a, TypeB#lastevent as b;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()).AddListener("s0"); MakeSendEvent(env, "TypeA", eventRepresentationEnum, startA, endA); MakeSendEvent(env, "TypeB", eventRepresentationEnum, startB, endB); Assert.AreEqual(true, env.Listener("s0").AssertOneGetNewAndReset().Get("val0")); 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 TryAssertionStreamInsertWWidenMap( RegressionEnvironment env, EventRepresentationChoice rep) { RegressionPath path = new RegressionPath(); string schemaSrc = rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSrc>() + "@Name('schema') create schema Src as (myint int, mystr string)"; env.CompileDeployWBusPublicType(schemaSrc, path); env.CompileDeploy( rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedD1>() + "create schema D1 as (myint int, mystr string, addprop long)", path); string eplOne = "insert into D1 select 1 as addprop, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplOne, "myint,mystr,addprop", new object[] {123, "abc", 1L}); env.CompileDeploy( rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedD2>() + "create schema D2 as (mystr string, myint int, addprop double)", path); string eplTwo = "insert into D2 select 1 as addprop, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplTwo, "myint,mystr,addprop", new object[] {123, "abc", 1d}); env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedD3>() + "create schema D3 as (mystr string, addprop int)", path); string eplThree = "insert into D3 select 1 as addprop, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplThree, "mystr,addprop", new object[] {"abc", 1}); env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedD4>() + "create schema D4 as (myint int, mystr string)", path); string eplFour = "insert into D4 select mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplFour, "myint,mystr", new object[] {123, "abc"}); string eplFive = "insert into D4 select mysrc.*, 999 as myint, 'xxx' as mystr from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplFive, "myint,mystr", new object[] {999, "xxx"}); string eplSix = "insert into D4 select 999 as myint, 'xxx' as mystr, mysrc.* from Src as mysrc"; RunStreamInsertAssertion(env, path, rep, eplSix, "myint,mystr", new object[] {999, "xxx"}); env.UndeployAll(); }
private static void TryAssertionInvalid( RegressionEnvironment env, EventRepresentationChoice rep) { RegressionPath path = new RegressionPath(); env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSrc>() + "create schema Src as (myint int, mystr string)", path); // mismatch in type env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedE1>() + "create schema E1 as (myint long)", path); string message = !rep.IsAvroEvent() ? "Type by name 'E1' in property 'myint' expected System.Nullable<System.Int32> but receives System.Nullable<System.Int64>" : "Type by name 'E1' in property 'myint' expected schema '{\"type\":\"long\"}' but received schema '{\"type\":\"int\"}'"; SupportMessageAssertUtil.TryInvalidCompile(env, path, "insert into E1 select mysrc.* from Src as mysrc", message); // mismatch in column name env.CompileDeploy(rep.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedE2>() + "create schema E2 as (someprop long)", path); SupportMessageAssertUtil.TryInvalidCompile( env, path, "insert into E2 select mysrc.*, 1 as otherprop from Src as mysrc", "Failed to find column 'otherprop' in target type 'E2' [insert into E2 select mysrc.*, 1 as otherprop from Src as mysrc]"); env.UndeployAll(); }
private static void TryAssertionNewWRepresentation( RegressionEnvironment env, EventRepresentationChoice rep, AtomicLong milestone) { var epl = rep.GetAnnotationTextWJsonProvided <MyLocalJsonProvided>() + "@Name('s0') select new { TheString = 'x' || TheString || 'x', IntPrimitive = IntPrimitive + 2} as val0 from SupportBean as sb"; env.CompileDeploy(epl).AddListener("s0").Milestone(milestone.GetAndIncrement()); Assert.AreEqual( rep.IsAvroEvent() ? typeof(GenericRecord) : typeof(IDictionary <string, object>), env.Statement("s0").EventType.GetPropertyType("val0")); var fragType = env.Statement("s0").EventType.GetFragmentType("val0"); if (rep == EventRepresentationChoice.JSONCLASSPROVIDED) { Assert.IsNull(fragType); } else { Assert.IsFalse(fragType.IsIndexed); Assert.IsFalse(fragType.IsNative); Assert.AreEqual(typeof(string), fragType.FragmentType.GetPropertyType("TheString")); Assert.AreEqual(typeof(int?), Boxing.GetBoxedType(fragType.FragmentType.GetPropertyType("IntPrimitive"))); } var fieldsInner = "TheString,IntPrimitive".SplitCsv(); env.SendEventBean(new SupportBean("E1", -5)); var @event = env.Listener("s0").AssertOneGetNewAndReset(); if (rep.IsAvroEvent()) { SupportAvroUtil.AvroToJson(@event); GenericRecord inner = (GenericRecord)@event.Get("val0"); Assert.AreEqual("xE1x", inner.Get("TheString")); Assert.AreEqual(-3, inner.Get("IntPrimitive")); } else { EPAssertionUtil.AssertPropsMap((IDictionary <string, object>)@event.Get("val0"), fieldsInner, "xE1x", -3); } env.UndeployAll(); }
private static void TryAssertionFullJoin_2sides_multicolumn( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var fields = new[] {"S0.Id", " S0.P00", " S0.P01", " S1.Id", " S1.P10", " S1.P11", " S2.Id", " S2.P20", " S2.P21"}; var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvided>() + " @Name('s0') select * from " + "SupportBean_S0#length(1000) as S0 " + " full outer join SupportBean_S1#length(1000) as S1 on S0.P00 = S1.P10 and S0.P01 = S1.P11" + " full outer join SupportBean_S2#length(1000) as S2 on S0.P00 = S2.P20 and S0.P01 = S2.P21"; env.CompileDeployAddListenerMileZero(epl, "s0"); env.SendEventBean(new SupportBean_S1(10, "A_1", "B_1")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, 10, "A_1", "B_1", null, null, null}); env.SendEventBean(new SupportBean_S1(11, "A_2", "B_1")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, 11, "A_2", "B_1", null, null, null}); env.SendEventBean(new SupportBean_S1(12, "A_1", "B_2")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, 12, "A_1", "B_2", null, null, null}); env.SendEventBean(new SupportBean_S1(13, "A_2", "B_2")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, 13, "A_2", "B_2", null, null, null}); env.SendEventBean(new SupportBean_S2(20, "A_1", "B_1")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, null, null, null, 20, "A_1", "B_1"}); env.SendEventBean(new SupportBean_S2(21, "A_2", "B_1")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, null, null, null, 21, "A_2", "B_1"}); env.SendEventBean(new SupportBean_S2(22, "A_1", "B_2")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, null, null, null, 22, "A_1", "B_2"}); env.SendEventBean(new SupportBean_S2(23, "A_2", "B_2")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, null, null, null, 23, "A_2", "B_2"}); env.SendEventBean(new SupportBean_S0(1, "A_3", "B_3")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {1, "A_3", "B_3", null, null, null, null, null, null}); env.SendEventBean(new SupportBean_S0(2, "A_1", "B_3")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {2, "A_1", "B_3", null, null, null, null, null, null}); env.SendEventBean(new SupportBean_S0(3, "A_3", "B_1")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {3, "A_3", "B_1", null, null, null, null, null, null}); env.SendEventBean(new SupportBean_S0(4, "A_2", "B_2")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {4, "A_2", "B_2", 13, "A_2", "B_2", 23, "A_2", "B_2"}); env.SendEventBean(new SupportBean_S0(5, "A_2", "B_1")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {5, "A_2", "B_1", 11, "A_2", "B_1", 21, "A_2", "B_1"}); env.SendEventBean(new SupportBean_S1(14, "A_4", "B_3")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, 14, "A_4", "B_3", null, null, null}); env.SendEventBean(new SupportBean_S1(15, "A_1", "B_3")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {2, "A_1", "B_3", 15, "A_1", "B_3", null, null, null}); env.SendEventBean(new SupportBean_S2(24, "A_1", "B_3")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {2, "A_1", "B_3", 15, "A_1", "B_3", 24, "A_1", "B_3"}); env.SendEventBean(new SupportBean_S2(25, "A_2", "B_3")); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {null, null, null, null, null, null, 25, "A_2", "B_3"}); env.UndeployAll(); }
private static void TryAssertionDocExample( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var path = new RegressionPath(); var baseModuleEPL = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedOrderEvent>() + " create schema OrderEvent as (OrderId string, ProductId string, Price double, Quantity int, DeletedFlag boolean)"; env.CompileDeployWBusPublicType(baseModuleEPL, path); var appModuleOne = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedProductTotalRec>() + " create schema ProductTotalRec as (ProductId string, TotalPrice double);" + "" + "@Name('nwProd') create window ProductWindow#unique(ProductId) as ProductTotalRec;" + "" + "on OrderEvent oe\n" + "merge ProductWindow pw\n" + "where pw.ProductId = oe.ProductId\n" + "when matched\n" + "then update set TotalPrice = TotalPrice + oe.Price\n" + "when not matched\n" + "then insert select ProductId, Price as TotalPrice;"; env.CompileDeploy(appModuleOne, path); var appModuleTwo = " @Name('nwOrd') create window OrderWindow#keepall as OrderEvent;" + "" + "on OrderEvent oe\n" + " merge OrderWindow pw\n" + " where pw.OrderId = oe.OrderId\n" + " when not matched \n" + " then insert select *\n" + " when matched and oe.DeletedFlag=true\n" + " then delete\n" + " when matched\n" + " then update set pw.Quantity = oe.Quantity, pw.Price = oe.Price"; env.CompileDeploy(appModuleTwo, path); SendOrderEvent(env, eventRepresentationEnum, "O1", "P1", 10, 100, false); SendOrderEvent(env, eventRepresentationEnum, "O1", "P1", 11, 200, false); SendOrderEvent(env, eventRepresentationEnum, "O2", "P2", 3, 300, false); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.Statement("nwProd").GetEnumerator(), new[] {"ProductId", "TotalPrice"}, new[] {new object[] {"P1", 21d}, new object[] {"P2", 3d}}); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.Statement("nwOrd").GetEnumerator(), new[] {"OrderId", "Quantity"}, new[] {new object[] {"O1", 200}, new object[] {"O2", 300}}); var module = "create schema StreetCarCountSchema (streetId string, carcount int);" + " create schema StreetChangeEvent (streetId string, action string);" + " create window StreetCarCountWindow#unique(streetId) as StreetCarCountSchema;" + " on StreetChangeEvent ce merge StreetCarCountWindow w where ce.streetId = w.streetId\n" + " when not matched and ce.action = 'ENTER' then insert select streetId, 1 as carcount\n" + " when matched and ce.action = 'ENTER' then update set StreetCarCountWindow.carcount = carcount + 1\n" + " when matched and ce.action = 'LEAVE' then update set StreetCarCountWindow.carcount = carcount - 1;" + " select * from StreetCarCountWindow;"; env.CompileDeploy(module, path); env.UndeployAll(); }
private static void TryAssertionSubselect( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var fields = new[] {"col1", "col2"}; var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyEvent>() + " create schema MyEvent as (in1 string, in2 int);\n"; epl += eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMySchema>() + " create schema MySchema as (col1 string, col2 int);\n"; epl += "@Name('create') create window MyWindowSS#lastevent as MySchema;\n"; epl += "on SupportBean_A delete from MyWindowSS;\n"; epl += "on MyEvent me " + "merge MyWindowSS mw " + "when not matched and (select IntPrimitive>0 from SupportBean(TheString like 'A%')#lastevent) then " + "insert(col1, col2) select (select TheString from SupportBean(TheString like 'A%')#lastevent), (select IntPrimitive from SupportBean(TheString like 'A%')#lastevent) " + "when matched and (select IntPrimitive>0 from SupportBean(TheString like 'B%')#lastevent) then " + "update set col1=(select TheString from SupportBean(TheString like 'B%')#lastevent), col2=(select IntPrimitive from SupportBean(TheString like 'B%')#lastevent) " + "when matched and (select IntPrimitive>0 from SupportBean(TheString like 'C%')#lastevent) then " + "delete;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()); // no action tests SendMyEvent(env, eventRepresentationEnum, "X1", 1); env.SendEventBean(new SupportBean("A1", 0)); // ignored SendMyEvent(env, eventRepresentationEnum, "X2", 2); env.SendEventBean(new SupportBean("A2", 20)); EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("create"), fields, null); SendMyEvent(env, eventRepresentationEnum, "X3", 3); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.GetEnumerator("create"), fields, new[] {new object[] {"A2", 20}}); env.SendEventBean(new SupportBean_A("Y1")); env.SendEventBean(new SupportBean("A3", 30)); EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("create"), fields, null); SendMyEvent(env, eventRepresentationEnum, "X4", 4); env.SendEventBean(new SupportBean("A4", 40)); SendMyEvent(env, eventRepresentationEnum, "X5", 5); // ignored as matched (no where clause, no B event) EPAssertionUtil.AssertPropsPerRowAnyOrder( env.GetEnumerator("create"), fields, new[] {new object[] {"A3", 30}}); env.SendEventBean(new SupportBean("B1", 50)); SendMyEvent(env, eventRepresentationEnum, "X6", 6); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.GetEnumerator("create"), fields, new[] {new object[] {"B1", 50}}); env.SendEventBean(new SupportBean("B2", 60)); SendMyEvent(env, eventRepresentationEnum, "X7", 7); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.GetEnumerator("create"), fields, new[] {new object[] {"B2", 60}}); env.SendEventBean(new SupportBean("B2", 0)); SendMyEvent(env, eventRepresentationEnum, "X8", 8); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.GetEnumerator("create"), fields, new[] {new object[] {"B2", 60}}); env.SendEventBean(new SupportBean("C1", 1)); SendMyEvent(env, eventRepresentationEnum, "X9", 9); EPAssertionUtil.AssertPropsPerRowAnyOrder(env.GetEnumerator("create"), fields, null); env.SendEventBean(new SupportBean("C1", 0)); SendMyEvent(env, eventRepresentationEnum, "X10", 10); EPAssertionUtil.AssertPropsPerRowAnyOrder( env.GetEnumerator("create"), fields, new[] {new object[] {"A4", 40}}); env.UndeployAll(); }
private static void TryAssertionStaggered( RegressionEnvironment env, EventRepresentationChoice outputType) { string[] fieldsOne = {"a1", "b1"}; string[] fieldsTwo = {"a2", "b2"}; var path = new RegressionPath(); // create window one var stmtTextCreateOne = outputType.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSTAG>() + "@Name('createOne') create window MyWindowSTAG#keepall as select TheString as a1, IntPrimitive as b1 from SupportBean"; env.CompileDeploy(stmtTextCreateOne, path).AddListener("createOne"); Assert.AreEqual(0, GetCount(env, "createOne", "MyWindowSTAG")); Assert.IsTrue(outputType.MatchesClass(env.Statement("createOne").EventType.UnderlyingType)); // create window two var stmtTextCreateTwo = outputType.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedSTAGTwo>() + " @Name('createTwo') create window MyWindowSTAGTwo#keepall as select TheString as a2, IntPrimitive as b2 from SupportBean"; env.CompileDeploy(stmtTextCreateTwo, path).AddListener("createTwo"); Assert.AreEqual(0, GetCount(env, "createTwo", "MyWindowSTAGTwo")); Assert.IsTrue(outputType.MatchesClass(env.Statement("createTwo").EventType.UnderlyingType)); // create delete stmt var stmtTextDelete = "@Name('delete') on MyWindowSTAG delete from MyWindowSTAGTwo where a1 = a2"; env.CompileDeploy(stmtTextDelete, path).AddListener("delete"); Assert.AreEqual( StatementType.ON_DELETE, env.Statement("delete").GetProperty(StatementProperty.STATEMENTTYPE)); // create insert into var stmtTextInsert = "@Name('insert') insert into MyWindowSTAG select TheString as a1, IntPrimitive as b1 from SupportBean(IntPrimitive > 0)"; env.CompileDeploy(stmtTextInsert, path); stmtTextInsert = "@Name('insertTwo') insert into MyWindowSTAGTwo select TheString as a2, IntPrimitive as b2 from SupportBean(IntPrimitive < 0)"; env.CompileDeploy(stmtTextInsert, path); SendSupportBean(env, "E1", -10); EPAssertionUtil.AssertProps( env.Listener("createTwo").AssertOneGetNewAndReset(), fieldsTwo, new object[] {"E1", -10}); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("createTwo"), fieldsTwo, new[] {new object[] {"E1", -10}}); Assert.IsFalse(env.Listener("createOne").IsInvoked); Assert.AreEqual(1, GetCount(env, "createTwo", "MyWindowSTAGTwo")); SendSupportBean(env, "E2", 5); EPAssertionUtil.AssertProps( env.Listener("createOne").AssertOneGetNewAndReset(), fieldsOne, new object[] {"E2", 5}); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("createOne"), fieldsOne, new[] {new object[] {"E2", 5}}); Assert.IsFalse(env.Listener("createTwo").IsInvoked); Assert.AreEqual(1, GetCount(env, "createOne", "MyWindowSTAG")); SendSupportBean(env, "E3", -1); EPAssertionUtil.AssertProps( env.Listener("createTwo").AssertOneGetNewAndReset(), fieldsTwo, new object[] {"E3", -1}); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("createTwo"), fieldsTwo, new[] {new object[] {"E1", -10}, new object[] {"E3", -1}}); Assert.IsFalse(env.Listener("createOne").IsInvoked); Assert.AreEqual(2, GetCount(env, "createTwo", "MyWindowSTAGTwo")); SendSupportBean(env, "E3", 1); EPAssertionUtil.AssertProps( env.Listener("createOne").AssertOneGetNewAndReset(), fieldsOne, new object[] {"E3", 1}); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("createOne"), fieldsOne, new[] {new object[] {"E2", 5}, new object[] {"E3", 1}}); EPAssertionUtil.AssertProps( env.Listener("createTwo").AssertOneGetOldAndReset(), fieldsTwo, new object[] {"E3", -1}); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("createTwo"), fieldsTwo, new[] {new object[] {"E1", -10}}); Assert.AreEqual(2, GetCount(env, "createOne", "MyWindowSTAG")); Assert.AreEqual(1, GetCount(env, "createTwo", "MyWindowSTAGTwo")); env.UndeployModuleContaining("delete"); env.UndeployModuleContaining("insert"); env.UndeployModuleContaining("insertTwo"); env.UndeployModuleContaining("createOne"); env.UndeployModuleContaining("createTwo"); }
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 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(); }
private static void TryAssertionScoringUseCase( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum, AtomicLong milestone) { var fields = new[] {"UserId", "Keyword", "SumScore"}; var epl = eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedScoreCycle>() + "create schema ScoreCycle (UserId string, Keyword string, ProductId string, Score long);\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedUserKeywordTotalStream>() + "create schema UserKeywordTotalStream (UserId string, Keyword string, SumScore long);\n" + "\n" + eventRepresentationEnum.GetAnnotationTextWJsonProvided(typeof(ExprCoreNewStruct.MyLocalJsonProvided)) + " create context HashByUserCtx as " + "coalesce by consistent_hash_crc32(UserId) from ScoreCycle, " + "consistent_hash_crc32(UserId) from UserKeywordTotalStream " + "granularity 1000000;\n" + "\n" + "context HashByUserCtx create window ScoreCycleWindow#unique(ProductId, Keyword) as ScoreCycle;\n" + "\n" + "context HashByUserCtx insert into ScoreCycleWindow select * from ScoreCycle;\n" + "\n" + "@Name('s0') context HashByUserCtx insert into UserKeywordTotalStream \n" + "select UserId, Keyword, sum(Score) as SumScore from ScoreCycleWindow group by Keyword;\n" + "\n" + "@Name('outTwo') context HashByUserCtx on UserKeywordTotalStream(SumScore > 10000) delete from ScoreCycleWindow;\n"; env.CompileDeployWBusPublicType(epl, new RegressionPath()); env.AddListener("s0"); MakeSendScoreEvent(env, "ScoreCycle", eventRepresentationEnum, "Pete", "K1", "P1", 100); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"Pete", "K1", 100L}); MakeSendScoreEvent(env, "ScoreCycle", eventRepresentationEnum, "Pete", "K1", "P2", 15); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"Pete", "K1", 115L}); MakeSendScoreEvent(env, "ScoreCycle", eventRepresentationEnum, "Joe", "K1", "P2", 30); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"Joe", "K1", 30L}); MakeSendScoreEvent(env, "ScoreCycle", eventRepresentationEnum, "Joe", "K2", "P1", 40); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"Joe", "K2", 40L}); MakeSendScoreEvent(env, "ScoreCycle", eventRepresentationEnum, "Joe", "K1", "P1", 20); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), fields, new object[] {"Joe", "K1", 50L}); env.UndeployAll(); }
private static void RunAssertionFields( RegressionEnvironment env, EventRepresentationChoice representationEnum, bool eventbean) { EPDataFlowInstantiationOptions options; var path = new RegressionPath(); var streamType = eventbean ? "EventBean<MyEvent>" : "MyEvent"; env.CompileDeploy( representationEnum.GetAnnotationTextWJsonProvided<MyLocalJsonProvidedMyEvent>() + "create schema MyEvent(p0 string, p1 long, p2 double)", path); env.CompileDeploy( "@Name('flow') create dataflow MyDataFlowOne " + "" + "BeaconSource -> BeaconStream<" + streamType + "> " + "{" + " iterations : 3," + " p0 : 'abc'," + " p1 : cast(Math.Round(Randomizer.Random() * 10) + 1, long)," + " p2 : 1d," + "}" + "DefaultSupportCaptureOp(BeaconStream) {}", path); var future = new DefaultSupportCaptureOp(3, env.Container.LockManager()); options = new EPDataFlowInstantiationOptions() .WithOperatorProvider(new DefaultSupportGraphOpProvider(future)); var df = env.Runtime.DataFlowService.Instantiate(env.DeploymentId("flow"), "MyDataFlowOne", options); df.Start(); object[] output; try { output = future.GetValue(2, TimeUnit.SECONDS); } catch (Exception t) { throw new EPException(t); } Assert.AreEqual(3, output.Length); for (var i = 0; i < 3; i++) { if (!eventbean) { if (representationEnum.IsObjectArrayEvent()) { var row = (object[]) output[i]; Assert.AreEqual("abc", row[0]); var val = row[1].AsInt64(); Assert.IsTrue(val >= 0 && val <= 11, "val=" + val); Assert.AreEqual(1d, row[2]); } else if (representationEnum.IsMapEvent()) { var row = (IDictionary<string, object>) output[i]; Assert.AreEqual("abc", row.Get("p0")); var val = row.Get("p1").AsInt64(); Assert.IsTrue(val >= 0 && val <= 11, "val=" + val); Assert.AreEqual(1d, row.Get("p2")); } else { var row = (GenericRecord) output[i]; Assert.AreEqual("abc", row.Get("p0")); var val = row.Get("p1").AsInt64(); Assert.IsTrue(val >= 0 && val <= 11, "val=" + val); Assert.AreEqual(1d, row.Get("p2")); } } else { var row = (EventBean) output[i]; Assert.AreEqual("abc", row.Get("p0")); } } env.UndeployAll(); }
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 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(); }