public void When_file_is_changed_will_automatically_get_new_version()
{
DslFactory factory = new DslFactory();
factory.BaseDirectory = AppDomain.CurrentDomain.BaseDirectory;
factory.Register <DemoDslBase>(new DemoDslEngine());
File.WriteAllText(path, "log 'test'");
DemoDslBase demo = factory.Create <DemoDslBase>(path);
demo.Execute();
Assert.Equal("test", demo.Messages[0]);
File.WriteAllText(path, "log 'changed'");
for (int i = 0; i < 5; i++)
{
Thread.Sleep(200); //let it time to refresh
demo = factory.Create <DemoDslBase>(path);
demo.Execute();
if (demo.Messages[0] == "changed")
{
break;
}
}
Assert.Equal("changed", demo.Messages[0]);
}
private static void Main()
{
var factory = new DslFactory();
factory.Register<DeclerativeDslBase>(new DeclerativeDslEngine());
while (true)
{
var dsl = factory.Create<DeclerativeDslBase>("Declerative.dsl");
dsl.Prepare();
dsl.Execute(
new Order { Total = 5000 },
new Customer { IsPreferred = false });
dsl.Execute(
new Order { Total = 5000 },
new Customer { IsPreferred = true });
dsl.Execute(
new Order { Total = 10 },
new Customer { IsPreferred = true });
Console.ReadKey();
}
}
private IBuildMetaData CreateBuildMetaData(DirectoryInfo buildFolder, string buildFile)
{
var buildFileResolver = new BuildFileResolver();
var buildFilePath = buildFileResolver.Resolve(buildFolder, buildFile).BuildFile;
try
{
configReader = factory.Create <BooConfigReader>(buildFilePath);
}
catch (InvalidOperationException e)
{
throw new MissingBuildFileException(buildFolder, e);
}
configReader.Prepare();
foreach (var packageInfo in configReader.PackageMetaData.PackageInfo)
{
if (packageInfo.Key == "version")
{
continue;
}
configReader.BuildMetaData.ProjectInfo.Add(packageInfo.Key, packageInfo.Value);
}
configReader.PackageMetaData.PackageInfo.Clear();
configReader.BuildMetaData.Version = buildFileResolver.Version;
return(configReader.BuildMetaData);
}
private void CanCompile(string script)
{
var dslFactory = new DslFactory();
dslFactory.Register<ResponseStrategy>(new ResponseStrategyDslEngine());
var strategy = dslFactory.Create<ResponseStrategy>(String.Format(@"Specs\TestDslScripts\{0}", script));
strategy.ShouldNotBeNull();
}
public ScriptModel BuildModel(string path)
{
var script = dslFactory.Create <PhantomBase>(path);
script.Execute();
return(script.Model);
}
public static List <SystemModule> Generate(string url, RequirementsInformation parameters)
{
QuoteGeneratorRule rule = dslFactory.Create <QuoteGeneratorRule>(url, parameters);
rule.Evaluate();
return(rule.Modules);
}
private Host GetHost(IDictionary<string, object> variables)
{
DslFactory dslFactory = new DslFactory();
HostDslEngine dslEngine = new HostDslEngine();
dslEngine.Storage = new FileSystemDslEngineStorageWithExtension("*.host");
dslFactory.Register<Host>(dslEngine);
return dslFactory.Create<Host>(@"config\APPTEST\APPTEST.host", variables);
}
public void Dsl_engine_can_take_parameters()
{
DslFactory _Factory = new DslFactory();
_Factory.BaseDirectory = AppDomain.CurrentDomain.BaseDirectory;
_Factory.Register<MyClassWithParams>(new DslEngineWithParameters());
MyClassWithParams classWithParams = _Factory.Create<MyClassWithParams>("DslFactoryFixture\\ScriptWithParameter.boo");
Assert.AreEqual("World", classWithParams.Hello("World"));
}
public void Dsl_engine_can_take_parameters()
{
DslFactory _Factory = new DslFactory();
_Factory.BaseDirectory = AppDomain.CurrentDomain.BaseDirectory;
_Factory.Register <MyClassWithParams>(new DslEngineWithParameters());
MyClassWithParams classWithParams = _Factory.Create <MyClassWithParams>("DslFactoryFixture\\ScriptWithParameter.boo");
Assert.Equal("World", classWithParams.Hello("World"));
}
public void TransitionActionTestFromDSL()
{
var stateMachine = new StateMachine();
var builder = _factory.Create <StateMachineBuilder>("SimpleStateMachine.boo");
builder.BuildStateMachine(stateMachine);
var context = new StateMachineContext(stateMachine, null, null);
context.Start();
TestStateMachineTask.Clear();
context.HandleEvent(1);
Assert.That(TestStateMachineTask.PhaseHistory.Count, Is.EqualTo(1));
context.HandleEvent(2);
Assert.That(TestStateMachineTask.PhaseHistory.Count, Is.EqualTo(3));
//Global init, Local Finalize, Global init
Assert.That(TestStateMachineTask.PhaseHistory[0], Is.EqualTo(StateTransitionPhase.StateInitialization));
Assert.That(TestStateMachineTask.PhaseHistory[1], Is.EqualTo(StateTransitionPhase.StateFinalization));
Assert.That(TestStateMachineTask.PhaseHistory[2], Is.EqualTo(StateTransitionPhase.StateInitialization));
//first inits, first finalizes, first inits
Assert.That(TestStateMachineTask.StateHistory[0], Is.SameAs(stateMachine.States[1]));
Assert.That(TestStateMachineTask.StateHistory[1], Is.SameAs(stateMachine.States[1]));
Assert.That(TestStateMachineTask.StateHistory[1], Is.SameAs(stateMachine.States[1]));
context.HandleEvent(1);
//first finalizes, initial inits
Assert.That(TestStateMachineTask.StateHistory[3], Is.SameAs(stateMachine.States[1]));
Assert.That(TestStateMachineTask.StateHistory[4], Is.SameAs(stateMachine.States[0]));
Assert.That(TestStateMachineTask.PhaseHistory[3], Is.EqualTo(StateTransitionPhase.StateFinalization));
Assert.That(TestStateMachineTask.PhaseHistory[4], Is.EqualTo(StateTransitionPhase.StateInitialization));
}
public void When_file_is_changed_will_automatically_get_new_version()
{
DslFactory factory = new DslFactory();
factory.BaseDirectory = AppDomain.CurrentDomain.BaseDirectory;
factory.Register<DemoDslBase>(new DemoDslEngine());
File.WriteAllText(path, "log 'test'");
DemoDslBase demo = factory.Create<DemoDslBase>(path);
demo.Execute();
Assert.Equal("test", demo.Messages[0]);
File.WriteAllText(path,"log 'changed'");
for (int i = 0; i < 5; i++)
{
Thread.Sleep(200);//let it time to refresh
demo = factory.Create<DemoDslBase>(path);
demo.Execute();
if(demo.Messages[0]=="changed")
break;
}
Assert.Equal("changed", demo.Messages[0]);
}
public when_configuring_daemon_using_dsl()
{
test_event = new DSLTestEvent(new Categorisation("TEST"), Guid.Empty);
publisher = new Publisher();
var factory = new DslFactory
{
BaseDirectory = AppDomain.CurrentDomain.BaseDirectory,
};
factory.Register<BaseDaemonConfigurationDSL>(new BaseDaemonConfigurationDSLEngine());
var dsl = factory.Create<BaseDaemonConfigurationDSL>("configuration.boo");
dsl.Prepare();
dsl.Execute();
}
public void Start()
{
log.InfoFormat("Starting the agent");
var factory = new DslFactory
{
BaseDirectory = AppDomain.CurrentDomain.BaseDirectory,
};
factory.Register<BaseDaemonConfigurationDSL>(new BaseDaemonConfigurationDSLEngine());
var dsl = factory.Create<BaseDaemonConfigurationDSL>("configuration.boo");
dsl.Prepare();
dsl.Execute();
schedulerFactory = new StdSchedulerFactory(ConfigurationManager.GetSection("quartz") as NameValueCollection);
scheduler = schedulerFactory.GetScheduler();
scheduler.Start();
}
private static void Main2()
{
var factory = new DslFactory();
factory.Register<SampleDslBase>(new SampleDslEngine());
var dsl = factory.Create<SampleDslBase>("sample.dsl");
dsl.Prepare();
var entity = new Account();
dsl.Creating(entity);
Console.WriteLine("Account numer was set to: " + entity.AccountNumber);
dsl.Creating(new Order
{
Account = new Account
{
MaxOrderTotal = 10
},
Total = 15
});
}
private static void Main()
{
var factory = new DslFactory();
factory.Register <DeclerativeDslBase>(new DeclerativeDslEngine());
while (true)
{
var dsl = factory.Create <DeclerativeDslBase>("Declerative.dsl");
dsl.Prepare();
dsl.Execute(
new Order {
Total = 5000
},
new Customer {
IsPreferred = false
});
dsl.Execute(
new Order {
Total = 5000
},
new Customer {
IsPreferred = true
});
dsl.Execute(
new Order {
Total = 10
},
new Customer {
IsPreferred = true
});
Console.ReadKey();
}
}
/// <summary>
/// Creates the state machine.
/// </summary>
/// <param name="stateMachineName">Name of the state machine.</param>
/// <returns>The state machine</returns>
public IStateMachine CreateStateMachine(string stateMachineName)
{
if (string.IsNullOrEmpty(stateMachineName))
{
throw new ArgumentNullException("stateMachineName");
}
string fileName = UnifyFileName(stateMachineName);
if (_machineBuilderCache.ContainsKey(fileName) == false)
{
_machineBuilderCache[fileName] = _factory.Create <StateMachineBuilder>(fileName);
}
StateMachineBuilder stateMachineBuilder = _machineBuilderCache[fileName];
var machine = new StateMachine {
Tag = stateMachineName
};
stateMachineBuilder.BuildStateMachine(machine);
return(machine);
}
private static void Main(string[] args)
{
Thread.CurrentThread.CurrentUICulture = new CultureInfo(1033);
try
{
var factory = new DslFactory();
factory.Register<PoplarTemplateFactory>(new PoplarDslEngine());
var templateFactory = factory.Create<PoplarTemplateFactory>(args[0], null);
templateFactory.Initialize();
var template = templateFactory.Template;
Console.WriteLine("{0}: {1}", template.Name, template.Description);
foreach (var parameter in template.Parameters)
{
Console.WriteLine(" {0}", parameter);
Console.WriteLine(" value: {0}", parameter.Value);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private static void Main2()
{
var factory = new DslFactory();
factory.Register <SampleDslBase>(new SampleDslEngine());
var dsl = factory.Create <SampleDslBase>("sample.dsl");
dsl.Prepare();
var entity = new Account();
dsl.Creating(entity);
Console.WriteLine("Account numer was set to: " + entity.AccountNumber);
dsl.Creating(new Order
{
Account = new Account
{
MaxOrderTotal = 10
},
Total = 15
});
}
protected override void Because()
{
configReader = factory.Create <BooConfigReader>(@"BuildConfigs/Horn/hornprebuild.boo");
configReader.Prepare();
}
protected override void Because()
{
configReader = factory.Create <BooConfigReader>(@"BuildConfigs/Horn/versioneddependency.boo");
configReader.Prepare();
}
public void CanCompileFile()
{
Assert.IsNotNull(factory.Create <StateMachineBuilder>(@"testStateMachine.boo"));
}
