public static IObservable <StartUnitTest> GetTargetsFromBfc(string bfcFile, IServiceCommandFactory parseTestSyntax, IObservable <UnitTestResult> forParallelExection)
{
var pattern = bfcFile.Split('/', '\\');
var dir = pattern.Take(pattern.Length - 1).ToStringEach("/");
var filePattern = pattern.Last();
var watchers = new CompositeDisposable();
return(Rxn.Create <StartUnitTest>(o =>
{
Files.WatchForChanges(dir, filePattern, true, false, false).SelectMany(_ => TestWorkflow.StartIntegrationTest(File.ReadAllText(bfcFile), parseTestSyntax, forParallelExection).Do(dll => o.OnNext(dll)))
.Until().DisposedBy(watchers);
if (bfcFile.EndsWith(".bfc", StringComparison.InvariantCultureIgnoreCase))
{
if (!File.Exists(bfcFile))
{
$"Could not find theBFG command file: {bfcFile}".LogDebug();
o.OnCompleted();
}
TestWorkflow.StartIntegrationTest(File.ReadAllText(bfcFile), parseTestSyntax, forParallelExection).Do(dll => o.OnNext(dll)).Until();
}
return watchers;
})
);
}
/// <summary>
/// Parses a service command from a string with format "serviceCommandClassName property1 property2 ... propertyN"
/// </summary>
/// <param name="command"></param>
/// <param name="resolver"></param>
/// <returns></returns>
public static IServiceCommand Parse(string command, IServiceCommandFactory resolver)
{
var cmdTokens = command.Split(' ');
var cmdType = cmdTokens[0];
try
{
return(resolver.Get(cmdType, cmdTokens.Skip(1).ToArray()));
}
catch (Exception e)
{
throw new ServiceCommandNotFound("Could not resolve cmd '{0}' with options '{1}' because {2}", cmdType, cmdTokens.Skip(1).ToStringEach(), e.Message);
}
}
public static string DefaultReactorName = "default"; //i want to let users configure this, so no const
public ReactorManager(IServiceCommandFactory cmdFactory, IRxnManager <IRxn> defaultReactorInputOutputStream, Func <string, Rxns.Interfaces.IReactor <IRxn> > reactorFactory, IRxnHistoryProvider eventHistory)
{
_rxnManager = defaultReactorInputOutputStream;
_reactorFactory = reactorFactory;
_eventHistory = eventHistory;
//we want raw access to the eventManager, not via IrxnProcessor/IReactTo
_rxnManager.CreateSubscription <StopReactor>().Do(r => StopReactor(r.Name)).Until().DisposedBy(this);
_rxnManager.CreateSubscription <StartReactor>().Do(r => StartReactor(r.Name)).Until().DisposedBy(this);
new DisposableAction(() =>
{
OnWarning("Shutting down. This usually should not happen!");
Reactors.Values.ForEach(r =>
{
r.Reactor.Dispose();
});
}).DisposedBy(this);
}
public static IObservable <StartUnitTest> StartIntegrationTest(string testExpression, IServiceCommandFactory cmds, IObservable <UnitTestResult> results)
{
var serial = testExpression.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries).Select(t => t.Trim()).Where(t => !t.IsNullOrWhitespace()).ToArray();
var stageNo = 0;
return(Rxn.Create <StartUnitTest>(o =>
{
var resources = new CompositeDisposable();
return serial
.SelectMany(cmd =>
{
var stageTrigger = new Subject <Unit>();
var parallel = cmd.Split(',', StringSplitOptions.RemoveEmptyEntries)
.SelectMany(t =>
{
var testSytax = t.Split(';', StringSplitOptions.RemoveEmptyEntries);
return Enumerable.Range(0, Int32.Parse(testSytax.Skip(1).FirstOrDefault().IsNullOrWhiteSpace("1"), NumberStyles.Any)).Select(_ => testSytax.Length > 0 ? testSytax[0].Trim() : string.Empty);
})
.Select(action =>
{
var tokens = action.Split(' ', StringSplitOptions.RemoveEmptyEntries);
return cmds.Get(tokens.First(), tokens.Skip(1));
})
.ToArray();
if (parallel.Length < 1)
{
return new Unit().ToObservable();
}
$"Starting stage {++stageNo} with {parallel.Length} tests in parallel".LogDebug();
var expectedResultIds = parallel.Select(t => t.Id).ToList();
results.Synchronize().Where(tr =>
{
if (expectedResultIds.Contains(tr.InResponseTo))
{
expectedResultIds.Remove(tr.InResponseTo);
}
if (expectedResultIds.Count < 1)
{
$"Stage {stageNo} complete".LogDebug();
stageTrigger.OnNext(new Unit());
stageTrigger.OnCompleted();
return true;
}
return false;
})
.FirstOrDefaultAsync()
.Until()
.DisposedBy(resources);
parallel.ForEach(t => o.OnNext((StartUnitTest)t));
return stageTrigger;
})
.Where(_ => stageNo >= serial.Length)
.FirstOrDefaultAsync()
.Do(_ => o.OnCompleted())
.FinallyR(() => resources.Dispose())
.Until()
;
}));
}
public static IObservable <StartUnitTest> GetTargets(string testSyntax, string[] args, Func <ITestArena[]> forCompete, IServiceCommandFactory parseTestSyntax, IObservable <UnitTestResult> forParallelExection)
{
return(testSyntax.IsNullOrWhitespace() ?
Rxn.Empty <StartUnitTest>() :
Rxn.DfrCreate <StartUnitTest>(() =>
{
if (!(testSyntax.Contains(".dll", StringComparison.InvariantCultureIgnoreCase) ||
testSyntax.Contains(".csproj", StringComparison.InvariantCultureIgnoreCase) ||
testSyntax.Contains(".bfc", StringComparison.InvariantCultureIgnoreCase)))
{
"Target must be either .dll or .csproj or .bfc".LogDebug();
return Rxn.Empty <StartUnitTest>();
}
if (testSyntax.Contains(".bfc"))
{
return GetTargetsFromBfc(testSyntax, parseTestSyntax, forParallelExection);
}
if (!testSyntax.Contains("*"))
{
return GetTargetsFromDll(args, testSyntax, forCompete);
}
else
{
return GetTargetsFromPath(args, testSyntax, forCompete);
}
})
.Select(e =>
{
e.Dll = e.Dll.AsCrossPlatformPath();
if (!FocusedTest.IsNullOrWhitespace())
{
e.RunThisTest = FocusedTest;
}
return e;
}));
}
/// <summary>
/// Tnis function will parse an arg list for a set of firing targets.
/// Depending on the firing mode, the function will return a series of
/// startunittest sessions that represent the target as it grows over time.
/// </summary>
/// <param name="args">The startup commands for the bfg</param>
/// <param name="arena">When compete mode is detected, the area will be used to list tests to fire on</param>
/// <returns></returns>
public static IObservable <StartUnitTest[]> DetectAndWatchTargets(string[] args, Func <ITestArena[]> forCompete, IServiceCommandFactory integrationTestParsing, IObservable <UnitTestResult> integrationTestResults)
{
var dllOrTestSynax = GetDllFromArgs(args);//heck to remove the unwated tokens
return(GetTargets(dllOrTestSynax, args, forCompete, integrationTestParsing, integrationTestResults)
.Buffer(TimeSpan.FromSeconds(1))
.Where(l => l.Count > 0)
.Select(l => l.ToArray())
.Replay(1)
.RefCount()
);
}
