private static void TryInvalidStage(
RegressionEnvironment env,
EPStage stage,
string[] idsStaged)
{
TryInvalidStage(env, stage, idsStaged, "skip");
}
public void Run(RegressionEnvironment env)
{
RegressionPath path = new RegressionPath();
env.CompileDeploy("@Name('create') @public create window MyWindow#keepall as SupportBean", path);
EPStage stage = env.Runtime.StageService.GetStage("S1");
string idCreate = env.DeploymentId("create");
string namedWindowObjectName = "named window 'MyWindow'";
string eventTypeObjectName = "event type 'MyWindow'";
string[][] namedWindowDependencies = new string[][] {
new string[] { "select * from MyWindow", namedWindowObjectName },
new string[] { "insert into MyWindow select * from SupportBean", namedWindowObjectName },
new string[] { "select (select count(*) from MyWindow) from SupportBean", namedWindowObjectName },
new string[] { "on SupportBean delete from MyWindow", namedWindowObjectName },
new string[] { "select * from pattern[every MyWindow]", eventTypeObjectName },
new string[] { "on MyWindow merge MyWindow where 1=1 when not matched then insert into ABC select *", namedWindowObjectName }
};
foreach (string[] line in namedWindowDependencies)
{
AssertPrecondition(env, path, stage, idCreate, line[1], line[0]);
}
env.UndeployAll();
}
public RegressionEnvironment UndeployAll()
{
Runtime.DeploymentService.UndeployAll();
string[] stageURIs = Runtime.StageService.StageURIs;
foreach (string uri in stageURIs) {
EPStage stage = Runtime.StageService.GetExistingStage(uri);
stage.Destroy();
}
return this;
}
private static void AssertPrecondition(
RegressionEnvironment env,
RegressionPath path,
EPStage stage,
string idCreate,
string objectName,
string epl)
{
env.CompileDeploy("@Name('tester') " + epl, path);
string idTester = env.DeploymentId("tester");
TryInvalidStageProvides(env, stage, idCreate, idTester, objectName);
TryInvalidStageConsumes(env, stage, idTester, idCreate, objectName);
env.UndeployModuleContaining("tester");
}
public RegressionEnvironment SendEventBeanStage(
string stageUri,
object @event)
{
if (stageUri == null) {
return SendEventBean(@event);
}
EPStage stage = Runtime.StageService.GetExistingStage(stageUri);
if (stage == null) {
throw new EPRuntimeException("Failed to find stage '" + stageUri + "'");
}
stage.EventService.SendEventBean(@event, @event.GetType().Name);
return this;
}
public void Run(RegressionEnvironment env)
{
RegressionPath path = new RegressionPath();
env.CompileDeploy("@Name('variable') @public create variable int MyVariable", path);
env.CompileDeploy("@Name('stmt') select MyVariable from SupportBean_S0", path);
EPStage stage = env.Runtime.StageService.GetStage("S1");
string idCreate = env.DeploymentId("variable");
string idStmt = env.DeploymentId("stmt");
TryInvalidStageProvides(env, stage, idCreate, idStmt, "variable 'MyVariable'");
TryInvalidStageConsumes(env, stage, idStmt, idCreate, "variable 'MyVariable'");
env.UndeployAll();
}
public RegressionEnvironment AdvanceTimeStage(
string stageUri,
long msec)
{
if (stageUri == null) {
AdvanceTime(msec);
return this;
}
EPStage stage = Runtime.StageService.GetExistingStage(stageUri);
if (stage == null) {
throw new EPRuntimeException("Failed to find stage '" + stageUri + "'");
}
stage.EventService.AdvanceTime(msec);
return this;
}
public void Run(RegressionEnvironment env)
{
EPStage stageA = env.StageService.GetStage("ST");
env.CompileDeploy("@Name('s0') select * from SupportBean");
string deploymentId = env.DeploymentId("s0");
StageIt(env, "ST", deploymentId);
try {
stageA.Destroy();
Assert.Fail();
}
catch (EPException ex) {
Assert.AreEqual("Failed to destroy stage 'ST': The stage has existing deployments", ex.Message);
}
UnstageIt(env, "ST", deploymentId);
stageA.Destroy();
Assert.AreEqual("ST", stageA.URI);
TryInvalidDestroyed(() => Noop(stageA.EventService));
TryInvalidDestroyed(() => Noop(stageA.DeploymentService));
TryInvalidDestroyed(
() => {
try {
stageA.Stage(Collections.SingletonList(deploymentId));
}
catch (EPStageException ex) {
throw new EPRuntimeException(ex);
}
});
TryInvalidDestroyed(
() => {
try {
stageA.Unstage(Collections.SingletonList(deploymentId));
}
catch (EPStageException ex) {
throw new EPRuntimeException(ex);
}
});
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
EPStage stageA = env.StageService.GetStage("ST");
TryIllegalArgument(() => stageA.Stage(null));
TryOp(() => stageA.Stage(EmptyList <string> .Instance));
TryIllegalArgument(() => stageA.Stage(Arrays.AsList(new string[] { null })));
TryIllegalArgument(() => stageA.Stage(Arrays.AsList(new string[] { "a", null })));
TryIllegalArgument(() => stageA.Unstage(null));
TryOp(() => stageA.Unstage(EmptyList <string> .Instance));
TryIllegalArgument(() => stageA.Unstage(Arrays.AsList(new string[] { null })));
TryIllegalArgument(() => stageA.Unstage(Arrays.AsList(new string[] { "a", null })));
TryDeploymentNotFound(() => stageA.Stage(Arrays.AsList(new string[] { "x" })), "Deployment 'x' was not found");
TryDeploymentNotFound(() => stageA.Unstage(Arrays.AsList(new string[] { "x" })), "Deployment 'x' was not found");
}
private static void TryInvalidStageConsumes(
RegressionEnvironment env,
EPStage stage,
string idStaged,
string idProviding,
string objectName)
{
string expected = "Failed to stage deployment '" +
idStaged +
"': Deployment consumes " +
objectName +
" from deployment '" +
idProviding +
"' and must therefore also be staged";
TryInvalidStage(env, stage, new string[] { idStaged }, expected);
}
private static void RunAssertion(
RegressionEnvironment env,
RegressionPath path,
EPStage stage,
string typename,
object underlying,
Consumer <EPEventService> sender)
{
string epl = "@public @buseventtype create schema TriggerEvent();\n" +
"@public @buseventtype @name('schema') create json schema " +
JSON_TYPENAME +
"();\n" +
"@Name('trigger') select * from TriggerEvent;\n" +
"@Name('s0') select * from " +
typename +
";\n";
env.CompileDeploy(epl, path).AddListener("s0");
string deploymentId = env.DeploymentId("s0");
StageIt(env, "ST", deploymentId);
// test normal send
sender.Invoke(stage.EventService);
AssertUnderlying(env, typename, underlying);
// test EventSender#send
EventSender eventSender = stage.EventService.GetEventSender(typename);
eventSender.SendEvent(underlying);
AssertUnderlying(env, typename, underlying);
// test EventSender#route
GetStatement("trigger", "ST", env.Runtime).Events += (_, args) => { eventSender.RouteEvent(underlying); };
stage.EventService.SendEventMap(new Dictionary <string, object>(), "TriggerEvent");
AssertUnderlying(env, typename, underlying);
UnstageIt(env, "ST", deploymentId);
path.Clear();
env.UndeployModuleContaining("s0");
}
private static void TryInvalidStage(
RegressionEnvironment env,
EPStage stage,
string[] idsStaged,
string message)
{
try {
stage.Stage(Arrays.AsList(idsStaged));
Assert.Fail();
}
catch (EPStagePreconditionException ex) {
if (!message.Equals("skip"))
{
AssertMessage(ex.Message, message);
}
}
catch (EPStageException) {
throw;
}
}
public void Run(RegressionEnvironment env)
{
RegressionPath path = new RegressionPath();
env.CompileDeploy("@Name('context') @public create context MyContext initiated by SupportBean", path);
env.CompileDeploy("@Name('stmt') context MyContext select count(*) from SupportBean_S0", path);
EPStage stage = env.Runtime.StageService.GetStage("S1");
string idCreate = env.DeploymentId("context");
string idStmt = env.DeploymentId("stmt");
TryInvalidStageProvides(env, stage, idCreate, idStmt, "context 'MyContext'");
TryInvalidStageConsumes(env, stage, idStmt, idCreate, "context 'MyContext'");
env.CompileDeploy("@Name('stmt-2') context MyContext select count(*) from SupportBean_S1", path);
string idStmt2 = env.DeploymentId("stmt-2");
TryInvalidStage(env, stage, new string[] { idCreate, idStmt });
TryInvalidStage(env, stage, new string[] { idStmt2, idStmt });
TryInvalidStage(env, stage, new string[] { idStmt2, idCreate });
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
EPStage stage = env.StageService.GetStage("ST");
RegressionPath path = new RegressionPath();
// Bean
RunAssertion(
env,
path,
stage,
"SupportBean",
new SupportBean(),
svc => svc.SendEventBean(new SupportBean(), "SupportBean"));
// Map
RunAssertion(
env,
path,
stage,
MAP_TYPENAME,
new Dictionary <string, object>(),
svc => svc.SendEventMap(new Dictionary <string, object>(), MAP_TYPENAME));
// Object-Array
RunAssertion(
env,
path,
stage,
OA_TYPENAME,
new object[0],
svc => svc.SendEventObjectArray(new object[0], OA_TYPENAME));
// XML
var node = SupportXML.GetDocument("<myevent/>").DocumentElement;
RunAssertion(
env,
path,
stage,
XML_TYPENAME,
node,
svc => svc.SendEventXMLDOM(node, XML_TYPENAME));
// Avro
var schema = AvroSchemaUtil.ResolveAvroSchema(env.Runtime.EventTypeService.GetEventTypePreconfigured(AVRO_TYPENAME));
var record = new GenericRecord(schema.AsRecordSchema());
RunAssertion(
env,
path,
stage,
AVRO_TYPENAME,
record,
svc => svc.SendEventAvro(record, AVRO_TYPENAME));
// Json
RunAssertion(
env,
path,
stage,
JSON_TYPENAME,
"{}",
svc => svc.SendEventJson("{}", JSON_TYPENAME));
env.UndeployAll();
}
