public void GenerateLaunchActionFor_ReturnsActionWhichWouldLaunchTheSolution(KataName kataEnum)
{
//---------------Set up test pack-------------------
var vsHelper = Substitute.For <IVisualStudioHelper>();
vsHelper.LaunchProject(Arg.Any <string>()).Returns(true);
var kataAttemptRepository = Substitute.For <IKataAttemptRepository>();
var kataAttempt = Substitute.For <IKataAttempt>();
var kataConfig = Substitute.For <IKataAttemptConfiguration>();
kataAttempt.Config.Returns(kataConfig);
var kataArchive = Create(kataAttemptRepository: kataAttemptRepository,
visualStudioHelper: vsHelper);
var solutionPath = kataArchive.GenerateSolutionForAttempt(kataEnum);
kataAttemptRepository.LoadKataAttemptFrom(solutionPath.Location).Returns(kataAttempt);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var launchActionFor = kataArchive.GenerateLaunchActionFor(solutionPath.Location);
//---------------Test Result -----------------------
Assert.IsNotNull(launchActionFor);
vsHelper.Received(0).LaunchProject(solutionPath.Location);
launchActionFor();
vsHelper.Received(1).LaunchProject(solutionPath.Location);
}
private MenuItem MenuItemFor(KataName kataName, string title)
{
return(new MenuItem()
{
Header = title,
Command = new GenerateAndLaunchKataCommand(kataName, _kataArchive, _commandHelper, _eventAggregator)
});
}
private GenerateAndLaunchKataCommand Create(KataName kataName = KataName.Unknown,
IKataArchive kataArchive = null,
ICommandHelper commandHelper = null,
IEventAggregator eventAggregator = null)
{
return(new GenerateAndLaunchKataCommand(kataName,
kataArchive ?? Substitute.For <IKataArchive>(),
commandHelper ?? Substitute.For <ICommandHelper>(),
eventAggregator ?? Substitute.For <IEventAggregator>()));
}
public IKataAttempt GenerateSolutionForAttempt(KataName selectedKata)
{
var newKataAttempt = _kataAttemptRepository.CreateNewKataAttempt(selectedKata);
var attemptLocation = newKataAttempt.Location;
_eventAggregator.Publish <DisplayFeedbackEvent>(string.Format("CREATED SOLUTION [ {0} ] FOR [ {1} ]",
attemptLocation, selectedKata));
return(_kataAttemptRepository.LoadKataAttemptFrom(attemptLocation));
;
}
public IKataAttempt CreateNewKataAttempt(KataName selectedKata)
{
var katasFolder = EnsureFolderExists(GetKataraiKatasPath());
var attemptName = GenereateAttemptNameFor(selectedKata);
var attemptPath = Path.Combine(katasFolder.FullName, attemptName);
var attemptFolder = EnsureFolderExists(attemptPath);
return(_kataSolutionExtractor.ExtractKataTo(attemptPath, selectedKata)
? LoadKataAttemptFrom(attemptFolder)
: null);
}
public void GenerateLaunchActionFor_ReturnsAction(KataName kataEnum)
{
//---------------Set up test pack-------------------
var kataArchive = Create();
var solutionPath = kataArchive.GenerateSolutionForAttempt(kataEnum);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var launchActionFor = kataArchive.GenerateLaunchActionFor(solutionPath.Location);
//---------------Test Result -----------------------
Assert.IsNotNull(launchActionFor);
}
private IKataAttempt GenerateAndLaunchKata(IKataArchive kataArchive, KataName selectedKata)
{
var kataAttempt = kataArchive.GenerateSolutionForAttempt(selectedKata);
if (kataAttempt == null)
{
_traceLoggerHelper.LogToUi("Failed to find solution template for [ " + kataArchive + " ]");
return(null);
}
var launchAction = kataArchive.GenerateLaunchActionFor(kataAttempt.Location);
launchAction.Invoke();
_eventAggregator.Publish <ShowMainWindowEvent>();
return(kataAttempt);
}
public bool ExtractKataTo(string outputLocation, KataName kataName)
{
var fileName = kataName + _kataPackageExtension;
using (var stream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(_kataraiWpfPackagedkataPackages + fileName))
{
if (stream == null)
{
return(false);
}
using (var zip = ZipFile.Read(stream))
{
zip.ExtractAll(outputLocation);
}
}
return(true);
}
public void GenerateSolutionForAttempt_ShouldEmitFeedback(string kataName, KataName kataEnum)
{
//---------------Set up test pack-------------------
var eventAggregator = Substitute.For <IEventAggregator>();
var kataAttemptRepository = Substitute.For <IKataAttemptRepository>();
var kataAttempt = Substitute.For <IKataAttempt>();
var expected = RandomValueGen.GetRandomString();
kataAttempt.Location.Returns(expected);
kataAttemptRepository.CreateNewKataAttempt(kataEnum).Returns(kataAttempt);
var kataArchive = Create(eventAggregator, kataAttemptRepository);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
kataArchive.GenerateSolutionForAttempt(kataEnum);
//---------------Test Result -----------------------
kataAttemptRepository.Received().CreateNewKataAttempt(kataEnum);
eventAggregator.ShouldHavePublished <DisplayFeedbackEvent>(
ev => ev.Message ==
string.Format("CREATED SOLUTION [ {0} ] FOR [ {1} ]", expected, kataName));
}
public void GenerateSolutionForAttempt_ReturnsKataAttempt(string kataName, KataName kataEnum)
{
//---------------Set up test pack-------------------
var kataAttemptRepo = Substitute.For <IKataAttemptRepository>();
var kataAttempt = Substitute.For <IKataAttempt>();
var expected = RandomValueGen.GetRandomString();
kataAttempt.Location.Returns(expected);
kataAttemptRepo.CreateNewKataAttempt(kataEnum).Returns(kataAttempt);
kataAttemptRepo.LoadKataAttemptFrom(kataAttempt.Location).Returns(kataAttempt);
var kataArchive = Create(kataAttemptRepository: kataAttemptRepo);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var result = kataArchive.GenerateSolutionForAttempt(kataEnum);
//---------------Test Result -----------------------
Assert.IsNotNull(result);
kataAttemptRepo.Received(1).CreateNewKataAttempt(kataEnum);
kataAttemptRepo.Received(1).LoadKataAttemptFrom(kataAttempt.Location);
Assert.AreEqual(expected, result.Location);
}
public GenerateAndLaunchKataCommand(KataName kata,
IKataArchive kataArchive,
ICommandHelper commandHelper,
IEventAggregator eventAggregator)
{
if (kataArchive == null)
{
throw new ArgumentNullException(nameof(kataArchive));
}
if (commandHelper == null)
{
throw new ArgumentNullException(nameof(commandHelper));
}
if (eventAggregator == null)
{
throw new ArgumentNullException(nameof(eventAggregator));
}
_kata = kata;
_kataArchive = kataArchive;
_commandHelper = commandHelper;
_eventAggregator = eventAggregator;
}
public void CreateNewKataAttempt_ReturnsAttempDirectoryPath(string kataName, KataName kataEnum)
{
//---------------Set up test pack-------------------
var testStartDateTime = DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss");
var expectedAttemptPath = Path.Combine(GetSpecialFolder(),
string.Format(@"{0}-{1}", kataName, testStartDateTime));
var repository = CreateRepository();
if (Directory.Exists(expectedAttemptPath))
{
Directory.Delete(expectedAttemptPath, true);
}
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
string attemptPath = expectedAttemptPath;
try
{
var kataAttempt = repository.CreateNewKataAttempt(kataEnum);
attemptPath = kataAttempt.Location;
}
finally
{
if (Directory.Exists(attemptPath))
{
Directory.Delete(attemptPath, true);
}
}
//---------------Test Result -----------------------
var dateTime = DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss");
var latestExpectedAttemptPath = Path.Combine(GetSpecialFolder(),
string.Format(@"{0}-{1}", kataName, dateTime));
Assert.GreaterOrEqual(attemptPath, expectedAttemptPath);
Assert.LessOrEqual(attemptPath, latestExpectedAttemptPath);
}
public void GetKataPracticeMenuItems_UntilDynamicModuleLoadingIsImplemented_ShouldProvideMenuItemFor_(KataName expectedName, string expectedTitle)
{
//---------------Set up test pack-------------------
var sut = Create();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var results = sut.GetKataPracticeMenuItems();
//---------------Test Result -----------------------
Assert.IsNotNull(results);
Assert.IsTrue(results.Any(i => (i.Command as GenerateAndLaunchKataCommand).Kata == expectedName &&
i.Header as string == expectedTitle));
}
private string GenereateAttemptNameFor(KataName selectedKata)
{
var kataName = selectedKata + "-";
return(kataName.AppendTimeStamp());
}
