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(); }