internal static void AssertGeneratedCode(this GeneratedFolder structure)
{
var path = Path.Combine(structure.RootPath, structure.Name);
//TODO: Get from config.json
var count = 10;
while (!Directory.Exists(path) && count > 0)
{
Debug.WriteLine($"Checking '{path}, attempts: {count}'");
count -= 1;
Thread.Sleep(DefaultSleepTime);
}
Directory.Exists(path).Should().BeTrue($"Folder doesn't exist: '{path}'");
foreach (var folder in structure.Folders)
{
AssertGeneratedCode(folder);
}
foreach (var file in structure.Files)
{
var filePath = Path.Combine(file.RootPath, file.Name);
File.Exists(filePath).Should().BeTrue($"File '{filePath}' not found.");
if (file.Contents != Any)
{
var contents = File.ReadAllText(filePath);
contents.Should().BeEquivalentTo(file.Contents);
}
}
}
public GeneratedFolder WithFolder(string name, Func <GeneratedFolder, GeneratedFolder> updateFunc = null)
{
var folder = new GeneratedFolder(FullName, name);
if (updateFunc != null)
{
folder = updateFunc(folder);
}
Folders.Add(folder);
return(this);
}
private static void AssertSolutionStructureIsGeneratedCorrectly(string folderName, string tempPath)
{
var generatedFolder = new GeneratedFolder(tempPath, folderName)
.WithBootstrapping()
.WithDataFakeSetup()
.WithDataContractsDto()
.WithDataContractsProviders()
.WithDataFakeContainers()
.WithDataFakeContainersContracts()
.WithDataFakeProviderBuilders()
.WithDataFakeProviders()
.WithDataRealProviders()
.WithLauncher()
.WithModel()
.WithModelContracts()
.WithPresentation()
.WithPresentationContracts()
.WithFile($"{folderName}.sln", AssertionHelper.Any);
generatedFolder.AssertGeneratedCode();
}
public void ThenTheFolderContainsGeneratedEntityObjectsForNameForSolutionName(string folderName,
string entityName,
string solutionName)
{
var tempPath = Path.GetTempPath();
var structure = new GeneratedFolder(tempPath, folderName)
.WithFolder($"{solutionName}.Data.Contracts.Dto",
r =>
r.WithFile($"{entityName}Dto.cs", $@"using System;
namespace {solutionName}.Data.Contracts.Dto
{{
public class {entityName}Dto
{{
public Guid Id {{ get; set; }}
public string DisplayName {{ get; set; }}
public int Value {{ get; set; }}
}}
}}")).WithFolder($"{solutionName}.Model.Contracts", r => r.WithFile($"I{entityName}.cs", $@"namespace {solutionName}.Model.Contracts
{{
public interface I{entityName} : IAppModel
{{
string DisplayName {{ get; }}
int Value {{ get; set; }}
}}
}}"))
.WithFolder($"{solutionName}.Model", r =>
r.WithFile($"{entityName}.cs", $@"using {solutionName}.Model.Contracts;
namespace {solutionName}.Model
{{
internal class {entityName} : AppModel, I{entityName}
{{
private string _displayName;
public string DisplayName
{{
get => _displayName;
set => SetProperty(ref _displayName, value);
}}
private int _value;
public int Value
{{
get => _value;
set => SetProperty(ref _value, value);
}}
}}
}}").WithFile("Module.cs", $@"using System.Reflection;
using AutoMapper;
using JetBrains.Annotations;
using {solutionName}.Model.Contracts;
using {solutionName}.Model.Mappers;
using Solid.Practices.IoC;
using Solid.Practices.Modularity;
namespace {solutionName}.Model
{{
[UsedImplicitly]
internal sealed class Module : ICompositionModule<IDependencyRegistrator>
{{
public void RegisterModule(IDependencyRegistrator dependencyRegistrator)
{{
dependencyRegistrator
.RegisterAutomagically(
Assembly.LoadFrom(AssemblyInfo.AssemblyName),
Assembly.GetExecutingAssembly());
var config = new MapperConfiguration(cfg =>
{{
cfg.AddProfile(new MappingProfile());
}});
var mapper = config.CreateMapper();
dependencyRegistrator
.AddInstance(mapper){(entityName=="Sample"?string.Empty:@"
.AddSingleton<SampleMapper>()")}
.AddSingleton<{entityName}Mapper>();
}}
}}
}}
").WithFolder("Mappers", s =>
s.WithFile("MappingProfile.cs", $@"using System;
using AutoMapper;
using {solutionName}.Data.Contracts.Dto;
using {solutionName}.Model.Contracts;
namespace {solutionName}.Model.Mappers
{{
internal sealed class MappingProfile : Profile
{{
public MappingProfile()
{{
CreateSampleItemMaps();
Create{entityName}Maps();
}}
private void Create{entityName}Maps()
{{
CreateDomainObjectMap<{entityName}Dto, I{entityName}, {entityName}>();
}}
private void CreateSampleItemMaps()
{{
CreateDomainObjectMap<SampleItemDto, ISampleItem, SampleItem>();
}}
private void CreateDomainObjectMap<TDto, TContract, TModel>()
where TModel : TContract where TContract : class => CreateDomainObjectMap(typeof(TDto), typeof(TContract), typeof(TModel));
private void CreateDomainObjectMap(Type dtoType, Type contractType, Type modelType)
{{
CreateMap(dtoType, contractType).As(modelType);
CreateMap(dtoType, modelType);
CreateMap(contractType, dtoType);
CreateMap(modelType, dtoType);
}}
}}
}}").WithFile($"{entityName}Mapper.cs", $@"using AutoMapper;
using JetBrains.Annotations;
using {solutionName}.Data.Contracts.Dto;
using {solutionName}.Model.Contracts;
namespace {solutionName}.Model.Mappers
{{
[UsedImplicitly]
internal sealed class {entityName}Mapper
{{
private readonly IMapper _mapper;
public {entityName}Mapper(IMapper mapper) => _mapper = mapper;
public I{entityName} MapTo{entityName}({entityName}Dto dto) =>
_mapper.Map<I{entityName}>(dto);
public {entityName}Dto MapFrom{entityName}(I{entityName} model) =>
_mapper.Map<{entityName}Dto>(model);
}}
}}")));
structure.AssertGeneratedCode();
}
public void ThenTheFolderContainsGeneratedEntityServiceObjectsForNameForSolutionName(string folderName,
string entityName,
string solutionName)
{
var tempPath = Path.GetTempPath();
var structure = new GeneratedFolder(tempPath, folderName)
.WithFolder($"{solutionName}.Data.Contracts.Providers",
r => r.WithFile($"I{entityName}DataProvider.cs",
$@"using System;
using System.Collections.Generic;
using {solutionName}.Data.Contracts.Dto;
namespace {solutionName}.Data.Contracts.Providers
{{
public interface I{entityName}DataProvider
{{
IEnumerable<{entityName}Dto> GetItems();
bool DeleteItem(Guid id);
bool UpdateItem({entityName}Dto dto);
void CreateItem({entityName}Dto dto);
}}
}}")).WithFolder($"{solutionName}.Model.Contracts",
r => r.WithFile($"I{entityName}Service.cs",
$@"using System.Collections.Generic;
using System.Threading.Tasks;
namespace {solutionName}.Model.Contracts
{{
public interface I{entityName}Service
{{
IEnumerable<I{entityName}> Items {{ get; }}
Task GetItems();
Task<I{entityName}> NewItem();
Task SaveItem(I{entityName} item);
Task DeleteItem(I{entityName} item);
}}
}}")).WithFolder($"{solutionName}.Data.Fake.Containers",
r => r.WithFile($"{entityName}DataContainer.cs",
$@"using System.Collections.Generic;
using {solutionName}.Data.Contracts.Dto;
using {solutionName}.Data.Fake.Containers.Contracts;
namespace {solutionName}.Data.Fake.Containers
{{
public interface I{entityName}DataContainer : IDataContainer
{{
IEnumerable<{entityName}Dto> Items {{ get; }}
}}
public sealed class {entityName}DataContainer : I{entityName}DataContainer
{{
private readonly List<{entityName}Dto> _items = new List<{entityName}Dto>();
public IEnumerable<{entityName}Dto> Items => _items;
public void UpdateItems(IEnumerable<{entityName}Dto> items)
{{
_items.Clear();
_items.AddRange(items);
}}
}}
}}")).WithFolder($"{solutionName}.Data.Fake.ProviderBuilders",
r => r.WithFile($"{entityName}ProviderBuilder.cs",
$@"using System;
using System.Collections.Generic;
using System.Linq;
using Attest.Fake.Builders;
using Attest.Fake.Core;
using Attest.Fake.Setup.Contracts;
using {solutionName}.Data.Contracts.Dto;
using {solutionName}.Data.Contracts.Providers;
namespace {solutionName}.Data.Fake.ProviderBuilders
{{
public sealed class {entityName}ProviderBuilder : FakeBuilderBase<I{entityName}DataProvider>.WithInitialSetup
{{
private readonly List<{entityName}Dto> _itemsStorage = new List<{entityName}Dto>();
private {entityName}ProviderBuilder()
{{
}}
public static {entityName}ProviderBuilder CreateBuilder() => new {entityName}ProviderBuilder();
public void WithItems(IEnumerable<{entityName}Dto> items)
{{
_itemsStorage.Clear();
_itemsStorage.AddRange(items);
}}
protected override IServiceCall<I{entityName}DataProvider> CreateServiceCall(
IHaveNoMethods<I{entityName}DataProvider> serviceCallTemplate) => serviceCallTemplate
.AddMethodCallWithResult(t => t.GetItems(),
r => r.Complete(GetItems))
.AddMethodCallWithResult<Guid, bool>(t => t.DeleteItem(It.IsAny<Guid>()),
(r, id) => r.Complete(DeleteItem(id)))
.AddMethodCallWithResult<{entityName}Dto, bool>(t => t.UpdateItem(It.IsAny<{entityName}Dto>()),
(r, dto) => r.Complete(k =>
{{
SaveItem(k);
return true;
}}))
.AddMethodCall<{entityName}Dto>(t => t.CreateItem(It.IsAny<{entityName}Dto>()),
(r, dto) => r.Complete(SaveItem));
private IEnumerable<{entityName}Dto> GetItems() => _itemsStorage;
private bool DeleteItem(Guid id)
{{
var dto = _itemsStorage.SingleOrDefault(x => x.Id == id);
return dto != null && _itemsStorage.Remove(dto);
}}
private void SaveItem({entityName}Dto dto)
{{
var oldDto = _itemsStorage.SingleOrDefault(x => x.Id == dto.Id);
if (oldDto == null)
{{
_itemsStorage.Add(dto);
}}
}}
}}
}}")).WithFolder($"{solutionName}.Data.Fake.Providers",
r => r.WithFile($"Fake{entityName}DataProvider.cs",
$@"using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Attest.Fake.Builders;
using JetBrains.Annotations;
using {solutionName}.Data.Contracts.Dto;
using {solutionName}.Data.Contracts.Providers;
using {solutionName}.Data.Fake.Containers;
using {solutionName}.Data.Fake.ProviderBuilders;
namespace {solutionName}.Data.Fake.Providers
{{
[UsedImplicitly]
internal sealed class Fake{entityName}DataProvider : FakeProviderBase<{entityName}ProviderBuilder, I{entityName}DataProvider>, I{entityName}DataProvider
{{
private readonly Random _random = new Random();
public Fake{entityName}DataProvider(
{entityName}ProviderBuilder sampleProviderBuilder,
I{entityName}DataContainer sampleContainer)
: base(sampleProviderBuilder)
{{
sampleProviderBuilder.WithItems(sampleContainer.Items);
}}
IEnumerable<{entityName}Dto> I{entityName}DataProvider.GetItems() => GetService(r =>
{{
Task.Delay(_random.Next(2000)).Wait();
return r;
}}).GetItems();
bool I{entityName}DataProvider.DeleteItem(Guid id) => GetService(r =>
{{
Task.Delay(_random.Next(2000)).Wait();
return r;
}}).DeleteItem(id);
bool I{entityName}DataProvider.UpdateItem({entityName}Dto dto) => GetService(r =>
{{
Task.Delay(_random.Next(2000)).Wait();
return r;
}}).UpdateItem(dto);
void I{entityName}DataProvider.CreateItem({entityName}Dto dto) => GetService(r =>
{{
Task.Delay(_random.Next(2000)).Wait();
return r;
}}).CreateItem(dto);
}}
}}")).WithFolder($"{solutionName}.Data.Fake.Providers",
r => r.WithFile("Module.cs",
$@"using System;
using JetBrains.Annotations;
using {solutionName}.Data.Contracts.Dto;
using {solutionName}.Data.Contracts.Providers;
using {solutionName}.Data.Fake.Containers;
using {solutionName}.Data.Fake.ProviderBuilders;
using Solid.Practices.IoC;
using Solid.Practices.Modularity;
namespace {solutionName}.Data.Fake.Providers
{{
[UsedImplicitly]
internal sealed class Module : ICompositionModule<IDependencyRegistrator>
{{
public void RegisterModule(IDependencyRegistrator dependencyRegistrator)
{{
dependencyRegistrator
.AddInstance(Initialize{entityName}Container())
.AddSingleton<I{entityName}DataProvider, Fake{entityName}DataProvider>();
dependencyRegistrator.RegisterInstance({entityName}ProviderBuilder.CreateBuilder());
}}
private I{entityName}DataContainer Initialize{entityName}Container()
{{
var container = new {entityName}DataContainer();
container.UpdateItems(new[]
{{
new {entityName}Dto
{{
Id = Guid.NewGuid(),
DisplayName = ""PC"",
Value = 8
}},
new {entityName}Dto
{{
Id = Guid.NewGuid(),
DisplayName = ""Acme"",
Value = 10
}},
new {entityName}Dto
{{
Id = Guid.NewGuid(),
DisplayName = ""Bacme"",
Value = 3
}},
new {entityName}Dto
{{
Id = Guid.NewGuid(),
DisplayName = ""Exceed"",
Value = 100
}},
new {entityName}Dto
{{
Id = Guid.NewGuid(),
DisplayName = ""Acme2"",
Value = 10
}}
}});
return container;
}}
}}
}}")).WithFolder($"{solutionName}.Data.Real.Providers",
r => r.WithFile($"{entityName}DataProvider.cs",
$@"using System;
using System.Collections.Generic;
using {solutionName}.Data.Contracts.Dto;
using {solutionName}.Data.Contracts.Providers;
namespace {solutionName}.Data.Real.Providers
{{
//TODO: Use explicit implementation
internal sealed class {entityName}DataProvider : I{entityName}DataProvider
{{
public IEnumerable<{entityName}Dto> GetItems()
{{
throw new NotImplementedException();
}}
public bool DeleteItem(Guid id)
{{
throw new NotImplementedException();
}}
public bool UpdateItem({entityName}Dto dto)
{{
throw new NotImplementedException();
}}
public void CreateItem({entityName}Dto dto)
{{
throw new NotImplementedException();
}}
}}
}}")).WithFolder($"{solutionName}.Model",
r => r.WithFile($"{entityName}Service.cs",
$@"using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using JetBrains.Annotations;
using LogoFX.Client.Core;
using LogoFX.Core;
using {solutionName}.Data.Contracts.Providers;
using {solutionName}.Model.Contracts;
using {solutionName}.Model.Mappers;
namespace {solutionName}.Model
{{
[UsedImplicitly]
internal sealed class {entityName}Service : NotifyPropertyChangedBase<{entityName}Service>, I{entityName}Service
{{
private readonly I{entityName}DataProvider _provider;
private readonly {entityName}Mapper _mapper;
private readonly RangeObservableCollection<I{entityName}> _items =
new RangeObservableCollection<I{entityName}>();
public {entityName}Service(I{entityName}DataProvider provider, {entityName}Mapper mapper)
{{
_provider = provider;
_mapper = mapper;
}}
private void GetItems()
{{
var items = _provider.GetItems().Select(_mapper.MapTo{entityName});
_items.Clear();
_items.AddRange(items);
}}
IEnumerable<I{entityName}> I{entityName}Service.Items => _items;
Task I{entityName}Service.GetItems() => MethodRunner.RunAsync(GetItems);
Task<I{entityName}> I{entityName}Service.NewItem() => MethodRunner.RunWithResultAsync<I{entityName}>(() => new {entityName}());
Task I{entityName}Service.SaveItem(I{entityName} item) => MethodRunner.RunAsync(() =>
{{
var dto = _mapper.MapFrom{entityName}(item);
if (item.IsNew)
{{
_provider.CreateItem(dto);
}}
else
{{
_provider.UpdateItem(dto);
}}
}});
Task I{entityName}Service.DeleteItem(I{entityName} item) => MethodRunner.RunAsync(() =>
{{
_provider.DeleteItem(item.Id);
_items.Remove(item);
}});
}}
}}")).WithFolder($"{solutionName}.Model.Contracts",
r => r.WithFile($"I{entityName}Service.cs",
$@"using System.Collections.Generic;
using System.Threading.Tasks;
namespace {solutionName}.Model.Contracts
{{
public interface I{entityName}Service
{{
IEnumerable<I{entityName}> Items {{ get; }}
Task GetItems();
Task<I{entityName}> NewItem();
Task SaveItem(I{entityName} item);
Task DeleteItem(I{entityName} item);
}}
}}"));
structure.AssertGeneratedCode();
}
