public async Task CancelBuildAsync_BatchTrainerCalled()
{
using (var env = new TestEnvironment())
{
await env.CreateEngineAsync();
await env.EngineRunner.InitNewAsync();
env.BatchTrainer.Train(Arg.Any <IProgress <ProgressData> >(), Arg.Do <Action>(checkCanceled =>
{
while (true)
{
checkCanceled();
}
}));
Build build = await env.EngineRunner.StartBuildAsync(env.Engine);
Assert.That(build, Is.Not.Null);
await Task.Delay(10);
await env.EngineRunner.CancelBuildAsync();
env.EngineRunner.WaitForBuildToComplete();
env.BatchTrainer.Received().Train(Arg.Any <IProgress <ProgressData> >(), Arg.Any <Action>());
env.BatchTrainer.DidNotReceive().Save();
build = await env.BuildRepository.GetAsync(build.Id);
Assert.That(build, Is.Null);
}
}
public async Task CancelBuildAsync_ProjectExistsNotBuilding_ReturnsTrue()
{
using (var env = new TestEnvironment())
{
string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
await env.CreateEngineServiceAsync();
bool result = await env.Service.CancelBuildAsync(BuildLocatorType.Engine, engineId);
Assert.That(result, Is.False);
}
}
public async Task StartBuildAsync_EngineExists_BuildStarted()
{
using (var env = new TestEnvironment())
{
string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
await env.CreateEngineServiceAsync();
Build build = await env.Service.StartBuildAsync(EngineLocatorType.Id, engineId);
Assert.That(build, Is.Not.Null);
}
}
public async Task TrainSegmentAsync_EngineExists_ReturnsTrue()
{
using (var env = new TestEnvironment())
{
string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
await env.CreateEngineServiceAsync();
bool result = await env.Service.TrainSegmentAsync(EngineLocatorType.Id, engineId,
"Esto es una prueba .".Split(), "This is a test .".Split());
Assert.That(result, Is.True);
}
}
public async Task TranslateAsync_EngineExists_ReturnsResult()
{
using (var env = new TestEnvironment())
{
string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
await env.CreateEngineServiceAsync();
TranslationResult result = await env.Service.TranslateAsync(EngineLocatorType.Id, engineId,
"Esto es una prueba .".Split());
Assert.That(result.TargetSegment, Is.EqualTo("this is a test .".Split()));
}
}
public async Task RemoveProjectAsync_ProjectDoesNotExist_ReturnsFalse()
{
using (var env = new TestEnvironment())
{
await env.CreateEngineAsync("es", "en", false);
await env.CreateEngineServiceAsync();
bool result = await env.Service.RemoveProjectAsync("project3");
Assert.That(result, Is.False);
}
}
public async Task AddProjectAsync_NonsharedProjectExists_ReturnsNull()
{
using (var env = new TestEnvironment())
{
await env.CreateEngineAsync("es", "en", false);
await env.CreateEngineServiceAsync();
Project project = await env.Service.AddProjectAsync("project1", "es", "en", "latin", "latin", false);
Assert.That(project, Is.Null);
}
}
public async Task TranslateAsync()
{
using (var env = new TestEnvironment())
{
await env.CreateEngineAsync(TimeSpan.FromHours(1));
await env.EngineRunner.InitNewAsync();
TranslationResult result = await env.EngineRunner.TranslateAsync("esto es una prueba .".Split());
Assert.That(result.TargetSegment, Is.EqualTo("this is a test .".Split()));
}
}
public async Task InteractiveTranslateAsync_EngineExists_ReturnsResult()
{
using (var env = new TestEnvironment())
{
string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
await env.CreateEngineServiceAsync();
HybridInteractiveTranslationResult result = await env.Service.InteractiveTranslateAsync(EngineLocatorType.Id,
engineId, "Esto es una prueba .".Split());
Assert.That(result.RuleResult.TargetSegment, Is.EqualTo("this is a test .".Split()));
Assert.That(result.SmtWordGraph.Arcs.SelectMany(a => a.Words), Is.EqualTo("this is a test .".Split()));
}
}
public async Task RemoveProjectAsync_NonsharedProjectExists_EngineRemoved()
{
using (var env = new TestEnvironment())
{
string engineId = (await env.CreateEngineAsync("es", "en", false)).Id;
await env.CreateEngineServiceAsync();
bool result = await env.Service.RemoveProjectAsync("project1");
Assert.That(result, Is.True);
Engine engine = await env.EngineRepository.GetAsync(engineId);
Assert.That(engine, Is.Null);
}
}
public async Task CommitAsync_LoadedActive()
{
using (var env = new TestEnvironment())
{
await env.CreateEngineAsync(TimeSpan.FromHours(1));
await env.EngineRunner.InitNewAsync();
await env.EngineRunner.TrainSegmentPairAsync("esto es una prueba .".Split(), "this is a test .".Split());
await env.EngineRunner.CommitAsync();
env.SmtModel.Received().Save();
Assert.That(env.EngineRunner.IsLoaded, Is.True);
}
}
public async Task AddProjectAsync_ProjectEngineExists_EngineCreated()
{
using (var env = new TestEnvironment())
{
string engineId = (await env.CreateEngineAsync("es", "en", false)).Id;
await env.CreateEngineServiceAsync();
Project project = await env.Service.AddProjectAsync("project2", "es", "en", "latin", "latin", true);
Assert.That(project, Is.Not.Null);
Engine engine = await env.EngineRepository.GetAsync(project.Engine);
Assert.That(engine.Id, Is.Not.EqualTo(engineId));
Assert.That(engine.Projects, Contains.Item("project2"));
}
}
public async Task Constructor_UnfinishedBuild_BuildStarted()
{
using (var env = new TestEnvironment())
{
string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
var build = new Build {
Id = "build1", EngineId = engineId
};
await env.BuildRepository.InsertAsync(build);
await env.CreateEngineServiceAsync();
// ensures that the build is completed
env.DisposeEngineService();
build = await env.BuildRepository.GetAsync("build1");
Assert.That(build, Is.Null);
}
}
